blob: 0a87c4eed01c7e7f64cdd26350a85d27dd5c458b [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>
Darth9cc683e72022-08-09 12:54:40 +010036#include <android-base/strings.h>
bigbiffcfa875c2021-06-20 16:20:27 -040037#include <libsnapshot/snapshot.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040038
Ethan Yonker007de982018-08-31 14:23:16 -050039#include "cutils/properties.h"
bigbiff7b4c7a62015-01-01 19:44:14 -050040#include "libblkid/include/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040041#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000042#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040043#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040044#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040045#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050046#include "twrpTar.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060047#include "exclude.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050048#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060049#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050050#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050051#include "adbbu/libtwadbbu.hpp"
Ethan Yonker98661c12018-10-17 08:39:28 -050052#ifdef TW_INCLUDE_CRYPTO
bigbiffdf53b6c2022-01-17 19:31:52 -050053 // #include "crypto/fde/cryptfs.h"
54 #include "cryptfs.h"
bigbiffa957f072021-03-07 18:20:29 -050055 #include "Decrypt.h"
Ethan Yonker98661c12018-10-17 08:39:28 -050056#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
bigbiffdf53b6c2022-01-17 19:31:52 -050078#define CRYPT_FOOTER_OFFSET 0x4000
79
bigbiff bigbiff9c754052013-01-09 09:09:08 -050080using namespace std;
81
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060082static 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
83
Dees_Troya95f55c2013-08-17 13:14:43 +000084extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050085extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000086
Hashcode62bd9e02013-11-19 21:59:42 -080087struct flag_list {
88 const char *name;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060089 unsigned long flag;
Hashcode62bd9e02013-11-19 21:59:42 -080090};
91
Matt Mower4ab42b12016-04-21 13:52:18 -050092const struct flag_list mount_flags[] = {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060093 { "noatime", MS_NOATIME },
94 { "noexec", MS_NOEXEC },
95 { "nosuid", MS_NOSUID },
96 { "nodev", MS_NODEV },
97 { "nodiratime", MS_NODIRATIME },
98 { "ro", MS_RDONLY },
99 { "rw", 0 },
100 { "remount", MS_REMOUNT },
101 { "bind", MS_BIND },
102 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000103#ifdef MS_UNBINDABLE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600104 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000105#endif
106#ifdef MS_PRIVATE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600107 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000108#endif
109#ifdef MS_SLAVE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600110 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000111#endif
112#ifdef MS_SHARED
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600113 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000114#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600115 { "sync", MS_SYNCHRONOUS },
116 { 0, 0 },
117};
118
119const char *ignored_mount_items[] = {
120 "defaults=",
121 "errors=",
Ethan Yonker93382822018-11-01 15:25:31 -0500122 "latemount",
123 "sysfs_path=",
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600124 NULL
Hashcode62bd9e02013-11-19 21:59:42 -0800125};
126
Matt Mower2416a502016-04-12 19:54:46 -0500127enum TW_FSTAB_FLAGS {
128 TWFLAG_DEFAULTS, // Retain position
129 TWFLAG_ANDSEC,
130 TWFLAG_BACKUP,
131 TWFLAG_BACKUPNAME,
132 TWFLAG_BLOCKSIZE,
133 TWFLAG_CANBEWIPED,
134 TWFLAG_CANENCRYPTBACKUP,
135 TWFLAG_DISPLAY,
136 TWFLAG_ENCRYPTABLE,
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500137 TWFLAG_FILEENCRYPTION,
Captain Throwbackf74fe4f2022-02-08 12:45:01 -0500138 TWFLAG_METADATA_ENCRYPTION,
Matt Mower2416a502016-04-12 19:54:46 -0500139 TWFLAG_FLASHIMG,
140 TWFLAG_FORCEENCRYPT,
141 TWFLAG_FSFLAGS,
142 TWFLAG_IGNOREBLKID,
143 TWFLAG_LENGTH,
144 TWFLAG_MOUNTTODECRYPT,
Captain Throwback8d97d422022-02-08 15:31:44 -0500145 TWFLAG_QUOTA,
Matt Mower2416a502016-04-12 19:54:46 -0500146 TWFLAG_REMOVABLE,
Matt Mower2416a502016-04-12 19:54:46 -0500147 TWFLAG_SETTINGSSTORAGE,
148 TWFLAG_STORAGE,
149 TWFLAG_STORAGENAME,
150 TWFLAG_SUBPARTITIONOF,
151 TWFLAG_SYMLINK,
152 TWFLAG_USERDATAENCRYPTBACKUP,
153 TWFLAG_USERMRF,
154 TWFLAG_WIPEDURINGFACTORYRESET,
155 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600156 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600157 TWFLAG_WAIT,
158 TWFLAG_VERIFY,
159 TWFLAG_CHECK,
160 TWFLAG_ALTDEVICE,
161 TWFLAG_NOTRIM,
162 TWFLAG_VOLDMANAGED,
163 TWFLAG_FORMATTABLE,
164 TWFLAG_RESIZE,
Ethan Yonker93382822018-11-01 15:25:31 -0500165 TWFLAG_KEYDIRECTORY,
Peter Cai28ea7b02019-05-24 11:38:54 +0800166 TWFLAG_WRAPPEDKEY,
Peter Cai439d60c2019-10-17 08:49:10 +0800167 TWFLAG_ADOPTED_MOUNT_DELAY,
Peter Caid68e6412019-11-02 19:22:38 +0800168 TWFLAG_DM_USE_ORIGINAL_PATH,
bigbiff998f8392021-08-06 19:19:33 -0400169 TWFLAG_LOGICAL,
Matt Mower2416a502016-04-12 19:54:46 -0500170};
171
172/* Flags without a trailing '=' are considered dual format flags and can be
173 * written as either 'flagname' or 'flagname=', where the character following
174 * the '=' is Y,y,1 for true and false otherwise.
175 */
176const struct flag_list tw_flags[] = {
177 { "andsec", TWFLAG_ANDSEC },
178 { "backup", TWFLAG_BACKUP },
179 { "backupname=", TWFLAG_BACKUPNAME },
180 { "blocksize=", TWFLAG_BLOCKSIZE },
181 { "canbewiped", TWFLAG_CANBEWIPED },
182 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
183 { "defaults", TWFLAG_DEFAULTS },
184 { "display=", TWFLAG_DISPLAY },
185 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500186 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Captain Throwbackf74fe4f2022-02-08 12:45:01 -0500187 { "metadata_encryption=", TWFLAG_METADATA_ENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500188 { "flashimg", TWFLAG_FLASHIMG },
189 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
190 { "fsflags=", TWFLAG_FSFLAGS },
191 { "ignoreblkid", TWFLAG_IGNOREBLKID },
192 { "length=", TWFLAG_LENGTH },
193 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
Captain Throwback8d97d422022-02-08 15:31:44 -0500194 { "quota", TWFLAG_QUOTA },
Matt Mower2416a502016-04-12 19:54:46 -0500195 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500196 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
197 { "storage", TWFLAG_STORAGE },
198 { "storagename=", TWFLAG_STORAGENAME },
199 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
200 { "symlink=", TWFLAG_SYMLINK },
201 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
202 { "usermrf", TWFLAG_USERMRF },
203 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
204 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600205 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600206 { "wait", TWFLAG_WAIT },
207 { "verify", TWFLAG_VERIFY },
208 { "check", TWFLAG_CHECK },
209 { "altdevice", TWFLAG_ALTDEVICE },
210 { "notrim", TWFLAG_NOTRIM },
211 { "voldmanaged=", TWFLAG_VOLDMANAGED },
212 { "formattable", TWFLAG_FORMATTABLE },
213 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500214 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800215 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800216 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800217 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
bigbiff998f8392021-08-06 19:19:33 -0400218 { "logical", TWFLAG_LOGICAL },
Matt Mower2416a502016-04-12 19:54:46 -0500219 { 0, 0 },
220};
221
that9e0593e2014-10-08 00:01:24 +0200222TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400223 Can_Be_Mounted = false;
224 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500225 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200226 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400227 Wipe_During_Factory_Reset = false;
228 Wipe_Available_in_GUI = false;
229 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400230 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400231 SubPartition_Of = "";
232 Symlink_Path = "";
233 Symlink_Mount_Point = "";
234 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400235 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600236 Wildcard_Block_Device = false;
237 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400238 Actual_Block_Device = "";
239 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400240 Alternate_Block_Device = "";
241 Removable = false;
242 Is_Present = false;
243 Length = 0;
244 Size = 0;
245 Used = 0;
246 Free = 0;
247 Backup_Size = 0;
248 Can_Be_Encrypted = false;
249 Is_Encrypted = false;
250 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600251 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600252 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400253 Decrypted_Block_Device = "";
254 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500255 Backup_Display_Name = "";
256 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400257 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400258 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400259 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500260 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000261 Can_Encrypt_Backup = false;
262 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400263 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400264 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400265 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500266 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400267 Storage_Path = "";
268 Current_File_System = "";
269 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800270 Mount_Flags = 0;
271 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400272 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000273 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800274 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600275 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600276 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500277 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600278 Is_Adopted_Storage = false;
279 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600280 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500281 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400282 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800283 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800284 Original_Path = "";
285 Use_Original_Path = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400286}
287
288TWPartition::~TWPartition(void) {
289 // Do nothing
290}
291
bigbiff8da46fa2020-09-08 16:42:34 -0400292bool 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 -0500293 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500294 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400295 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500296 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500297 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600298 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
299 TWPartition *additional_entry = NULL;
300 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400301
Matt Mower2b2dd152016-04-26 11:24:08 -0500302 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400303
Dees_Troy51127312012-09-08 13:08:49 -0400304 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500305 if (full_line[index] == 34)
306 skip = !skip;
307 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400308 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400309 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600310 if (line_len < 10)
311 return false; // There can't possibly be a valid fstab line that is less than 10 chars
bigbiff998f8392021-08-06 19:19:33 -0400312 if (fstab_line[0] == '#')
313 return false; // skip comments
314
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600315 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
316 fstab_version = 2;
317 block_device_index = 0;
318 mount_point_index = 1;
319 fs_index = 2;
320 }
321
bigbiff998f8392021-08-06 19:19:33 -0400322 if (fstab_line[0] != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400323 block_device_index = 0;
324 fstab_version = 2;
325 mount_point_index = 1;
326 fs_index = 2;
327 }
328
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600329 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400330 while (index < line_len) {
331 while (index < line_len && full_line[index] == '\0')
332 index++;
333 if (index >= line_len)
334 continue;
335 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600336 if (item_index == mount_point_index) {
337 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400338 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600339 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400340 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600341 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
342 }
343 }
bigbiff8da46fa2020-09-08 16:42:34 -0400344 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600345 Backup_Path = Mount_Point;
346 Storage_Path = Mount_Point;
347 Display_Name = ptr + 1;
348 Backup_Display_Name = Display_Name;
349 Storage_Name = Display_Name;
350 item_index++;
351 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400352 // File System
353 Fstab_File_System = ptr;
354 Current_File_System = ptr;
355 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600356 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400357 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400358 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400359 MTD_Name = ptr;
360 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400361 } else if (Fstab_File_System == "bml") {
362 if (Mount_Point == "/boot")
363 MTD_Name = "boot";
364 else if (Mount_Point == "/recovery")
365 MTD_Name = "recovery";
366 Primary_Block_Device = ptr;
367 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000368 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 -0400369 } else {
370 Primary_Block_Device = ptr;
bigbiff998f8392021-08-06 19:19:33 -0400371 if (*ptr == '/')
372 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400373 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400374 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600375 } else if (item_index > 2) {
376 if (fstab_version == 2) {
377 if (item_index == 3) {
378 Process_FS_Flags(ptr);
379 if (additional_entry) {
380 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
381 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
382 }
383 } else {
384 strlcpy(twflags, ptr, sizeof(twflags));
385 }
386 item_index++;
387 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400388 // Alternate Block Device
389 Alternate_Block_Device = ptr;
390 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
391 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
392 // Partition length
393 ptr += 7;
394 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400395 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
396 // Custom flags, save for later so that new values aren't overwritten by defaults
397 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500398 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400399 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
400 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400401 } else {
402 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500403 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400404 }
405 }
406 while (index < line_len && full_line[index] != '\0')
407 index++;
408 }
409
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600410 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
411 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
412 it = twrp_flags->find(Mount_Point);
413 if (it != twrp_flags->end()) {
414 if (!it->second.Primary_Block_Device.empty()) {
415 Primary_Block_Device = it->second.Primary_Block_Device;
416 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
417 }
418 if (!it->second.Alternate_Block_Device.empty()) {
419 Alternate_Block_Device = it->second.Alternate_Block_Device;
420 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
421 }
422 }
423 }
424
425 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
426 Sysfs_Entry = Primary_Block_Device;
427 Primary_Block_Device = "";
428 Is_Storage = true;
429 Removable = true;
430 Wipe_Available_in_GUI = true;
431 Wildcard_Block_Device = true;
432 }
433 if (Primary_Block_Device.find("*") != string::npos)
434 Wildcard_Block_Device = true;
435
bigbiff8da46fa2020-09-08 16:42:34 -0400436 if (Mount_Point == "auto") {
437 Mount_Point = "/auto";
438 char autoi[5];
439 sprintf(autoi, "%i", auto_index);
440 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600441 Backup_Path = Mount_Point;
442 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800443 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600444 auto_index++;
445 Setup_File_System(Display_Error);
446 Display_Name = "Storage";
447 Backup_Display_Name = Display_Name;
448 Storage_Name = Display_Name;
449 Can_Be_Backed_Up = false;
450 Wipe_Available_in_GUI = true;
451 Is_Storage = true;
452 Removable = true;
453 Wipe_Available_in_GUI = true;
454 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400455 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000456 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400457 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000458 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500459 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400460 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400461 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400462 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800463 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100464 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400465 Mount_Point = PartitionManager.Get_Android_Root_Path();
466 Backup_Path = Mount_Point;
467 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400468 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800469 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500470 Backup_Display_Name = Display_Name;
471 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400472 Wipe_Available_in_GUI = false;
473 Can_Be_Backed_Up = false;
474 Can_Be_Wiped = false;
bigbiff8da46fa2020-09-08 16:42:34 -0400475 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
me-cafebabe701e9ab2022-07-29 06:34:45 +0800476 } else if (Mount_Point == "/system_ext") {
477 Display_Name = "System_EXT";
478 Backup_Name = "System_EXT";
479 Backup_Display_Name = Display_Name;
480 Storage_Name = Display_Name;
481 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Mohd Faraze3948ec2020-08-14 01:40:59 +0000482 } else if (Mount_Point == "/product") {
483 Display_Name = "Product";
484 Backup_Name = "Product";
485 Backup_Display_Name = Display_Name;
486 Storage_Name = Display_Name;
487 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Mohd Faraze3948ec2020-08-14 01:40:59 +0000488 } else if (Mount_Point == "/odm") {
489 Display_Name = "ODM";
490 Backup_Name = "ODM";
491 Backup_Display_Name = Display_Name;
492 Storage_Name = Display_Name;
493 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400494 } else if (Mount_Point == "/data") {
495 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500496 Backup_Display_Name = Display_Name;
497 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400498 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400499 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500500 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000501 Can_Encrypt_Backup = true;
502 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400503 } else if (Mount_Point == "/cache") {
504 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500505 Backup_Display_Name = Display_Name;
506 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400507 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400508 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500509 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400510 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400511 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400512 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500513 Backup_Display_Name = Display_Name;
514 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400515 Is_SubPartition = true;
516 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400517 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500518 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000519 Can_Encrypt_Backup = true;
520 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400521 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400522 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400523 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500524 Backup_Display_Name = Display_Name;
525 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400526 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400527 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500528 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000529 Can_Encrypt_Backup = true;
530 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400531 } else if (Mount_Point == "/boot") {
532 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500533 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400534 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500535 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500536 } else if (Mount_Point == "/vendor") {
537 Display_Name = "Vendor";
538 Backup_Display_Name = Display_Name;
539 Storage_Name = Display_Name;
Dees_Troy8170a922012-09-18 15:40:25 -0400540 }
541#ifdef TW_EXTERNAL_STORAGE_PATH
542 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
543 Is_Storage = true;
544 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400545 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500546 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400547#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000548 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400549 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400550 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500551 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400552#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000553 }
Dees_Troy8170a922012-09-18 15:40:25 -0400554#ifdef TW_INTERNAL_STORAGE_PATH
555 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
556 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500557 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400558 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500559 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400560 }
561#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000562 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400563 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500564 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500565 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400566 }
567#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400568 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400569 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600570 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500571 if (Mount_Point == "/boot") {
572 Display_Name = "Boot";
573 Backup_Display_Name = Display_Name;
574 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600575 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500576 } else if (Mount_Point == "/recovery") {
577 Display_Name = "Recovery";
578 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600579 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500580 } else if (Mount_Point == "/system_image") {
581 Display_Name = "System Image";
582 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500583 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500584 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500585 } else if (Mount_Point == "/vendor_image") {
586 Display_Name = "Vendor Image";
587 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500588 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500589 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500590 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400591 }
592
Matt Mower2416a502016-04-12 19:54:46 -0500593 // Process TWRP fstab flags
594 if (strlen(twflags) > 0) {
595 string Prev_Display_Name = Display_Name;
596 string Prev_Storage_Name = Storage_Name;
597 string Prev_Backup_Display_Name = Backup_Display_Name;
598 Display_Name = "";
599 Storage_Name = "";
600 Backup_Display_Name = "";
601
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600602 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
603 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500604
605 bool has_display_name = !Display_Name.empty();
606 bool has_storage_name = !Storage_Name.empty();
607 bool has_backup_name = !Backup_Display_Name.empty();
608 if (!has_display_name) Display_Name = Prev_Display_Name;
609 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
610 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
611
612 if (has_display_name && !has_storage_name)
613 Storage_Name = Display_Name;
614 if (!has_display_name && has_storage_name)
615 Display_Name = Storage_Name;
616 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
617 Backup_Display_Name = Display_Name;
618 if (!has_display_name && has_backup_name)
619 Display_Name = Backup_Display_Name;
620 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600621
622 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
623 it = twrp_flags->find(Mount_Point);
624 if (it != twrp_flags->end()) {
625 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
626 int skip = 0;
627 string Flags = it->second.Flags;
628 strcpy(twrpflags, Flags.c_str());
629 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
630 skip += strlen("flags=");
631 char* flagptr = twrpflags;
632 flagptr += skip;
633 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
634 }
635 }
nkk7198fc3992017-12-16 16:26:42 +0200636
637 if (Mount_Point == "/persist" && Can_Be_Mounted) {
638 bool mounted = Is_Mounted();
639 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200640 TWFunc::Fixup_Time_On_Boot("/persist/time/");
641 if (!mounted)
642 UnMount(false);
643 }
644 }
645
Dees_Troy51127312012-09-08 13:08:49 -0400646 return true;
647}
648
Matt Mower72c87ce2016-04-26 14:34:56 -0500649void TWPartition::Partition_Post_Processing(bool Display_Error) {
650 if (Mount_Point == "/data")
651 Setup_Data_Partition(Display_Error);
652 else if (Mount_Point == "/cache")
653 Setup_Cache_Partition(Display_Error);
654}
655
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600656void TWPartition::ExcludeAll(const string& path) {
657 backup_exclusions.add_absolute_dir(path);
658 wipe_exclusions.add_absolute_dir(path);
659}
660
Matt Mower72c87ce2016-04-26 14:34:56 -0500661void TWPartition::Setup_Data_Partition(bool Display_Error) {
662 if (Mount_Point != "/data")
663 return;
664
665 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
666 UnMount(false);
667
668#ifdef TW_INCLUDE_CRYPTO
Matt Mower72c87ce2016-04-26 14:34:56 -0500669 Can_Be_Encrypted = true;
670 char crypto_blkdev[255];
671 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
672 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400673 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500674 Decrypted_Block_Device = crypto_blkdev;
675 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
bigbiff4fa02b52021-12-30 17:01:44 -0500676 if (datamedia)
677 Setup_Data_Media();
bigbiff7ba75002020-04-11 20:47:09 -0400678 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500679 } else if (!Mount(false)) {
680 if (Is_Present) {
me-cafebabeb0aab752022-06-10 01:45:40 +0800681 if (Key_Directory.empty()) {
682 set_partition_data(Use_Original_Path ? Original_Path.c_str() : Actual_Block_Device.c_str(), Crypto_Key_Location.c_str());
bigbiff7df87472022-09-24 16:45:03 -0400683 //if (cryptfs_check_footer() == 0) {
684 // Is_Encrypted = true;
685 // Is_Decrypted = false;
686 // Can_Be_Mounted = false;
687 // Current_File_System = "emmc";
688 // Setup_Image();
689 // DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
690 // DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
691 // DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
692 // DataManager::SetValue("tw_crypto_display", "");
693 // if (datamedia)
694 // Setup_Data_Media();
695 //}
696 // else {
697 // gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
698 //}
me-cafebabeb0aab752022-06-10 01:45:40 +0800699 } else {
700 Is_Encrypted = true;
701 Is_Decrypted = false;
702 if (datamedia)
703 Setup_Data_Media();
704 }
Ethan Yonker93382822018-11-01 15:25:31 -0500705 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400706 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
707 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500708 }
709 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400710 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500711 int is_device_fbe;
712 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
Captain Throwback8a8e56c2021-10-01 15:12:24 -0400713 char crypto_state[255];
714 property_get("ro.crypto.state", crypto_state, "error");
715 if (!Decrypt_FBE_DE() && strcmp(crypto_state, "error") != 0) {
716 if (is_device_fbe == 1)
717 LOGERR("Unable to decrypt FBE device\n");
718 } else {
719 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
bigbiff4fa02b52021-12-30 17:01:44 -0500720 if (datamedia)
721 Setup_Data_Media();
722
mauronofrio9bf73352019-11-23 22:27:34 +0100723 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500724 }
725 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
726 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400727 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500728 }
729#else
730 if (datamedia) {
731 Setup_Data_Media();
732 Recreate_Media_Folder();
733 }
734#endif
735}
736
bigbiff7ba75002020-04-11 20:47:09 -0400737void TWPartition::Set_FBE_Status() {
738 DataManager::SetValue(TW_IS_DECRYPTED, 1);
739 Is_Encrypted = true;
740 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400741 if (Key_Directory.empty()) {
742 Is_FBE = false;
743 DataManager::SetValue(TW_IS_FBE, 0);
744 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500745 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400746 Is_FBE = true;
747 DataManager::SetValue(TW_IS_FBE, 1);
748 }
749}
750
Ethan Yonker93382822018-11-01 15:25:31 -0500751bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400752 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500753 DataManager::SetValue(TW_IS_FBE, 1);
Captain Throwback37c3aef2021-10-06 11:38:18 -0400754 PartitionManager.Set_Crypto_State();
755 PartitionManager.Set_Crypto_Type("file");
Ethan Yonker93382822018-11-01 15:25:31 -0500756 LOGINFO("File Based Encryption is present\n");
757#ifdef TW_INCLUDE_FBE
Noah Jacobson81d638d2019-04-28 00:10:07 -0400758 Is_FBE = true;
759 ExcludeAll(Mount_Point + "/convert_fbe");
760 ExcludeAll(Mount_Point + "/unencrypted");
761 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
762 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
763 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
764 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
765 ExcludeAll(Mount_Point + "/system/locksettings.db");
766 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
767 ExcludeAll(Mount_Point + "/misc/gatekeeper");
768 ExcludeAll(Mount_Point + "/misc/keystore");
769 ExcludeAll(Mount_Point + "/drm/kek.dat");
bigbiffa957f072021-03-07 18:20:29 -0500770 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt synthetic password
micky3872ec1df42021-10-14 14:53:06 +0200771 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.password.key");
772 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.pattern.key");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400773 ExcludeAll(Mount_Point + "/cache");
774 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400775 ExcludeAll(Mount_Point + "/gsi"); // cow devices
776
Noah Jacobson81d638d2019-04-28 00:10:07 -0400777 int retry_count = 3;
bigbiffdf53b6c2022-01-17 19:31:52 -0500778 while (!android::keystore::Decrypt_DE() && --retry_count)
Noah Jacobson81d638d2019-04-28 00:10:07 -0400779 usleep(2000);
780 if (retry_count > 0) {
Captain Throwback37c3aef2021-10-06 11:38:18 -0400781 PartitionManager.Set_Crypto_State();
Noah Jacobson81d638d2019-04-28 00:10:07 -0400782 Is_Encrypted = true;
783 Is_Decrypted = false;
784 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
785 string filename;
bigbiffdf53b6c2022-01-17 19:31:52 -0500786 int pwd_type = android::keystore::Get_Password_Type(0, filename);
Noah Jacobson81d638d2019-04-28 00:10:07 -0400787 if (pwd_type < 0) {
788 LOGERR("This TWRP does not have synthetic password decrypt support\n");
789 pwd_type = 0; // default password
Ethan Yonker93382822018-11-01 15:25:31 -0500790 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400791 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
792 std::vector<users_struct>::iterator iter;
793 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
794 for (iter = userList->begin(); iter != userList->end(); iter++) {
795 if (atoi((*iter).userId.c_str()) != 0) {
796 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
797 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
798 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
799 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
800 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
801 }
802 }
803 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
804 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
805 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
806 DataManager::SetValue("tw_crypto_display", "");
807 return true;
808 }
Ethan Yonker93382822018-11-01 15:25:31 -0500809#else
810 LOGERR("FBE found but FBE support not present in TWRP\n");
811#endif
812 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500813 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500814 return false;
815}
816
Matt Mower72c87ce2016-04-26 14:34:56 -0500817void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
818 if (Mount_Point != "/cache")
819 return;
820
821 if (!Mount(true))
822 return;
823
824 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
825 LOGINFO("Recreating /cache/recovery folder\n");
826 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
827 LOGERR("Could not create /cache/recovery\n");
828 }
829}
830
Matt Mower4ab42b12016-04-21 13:52:18 -0500831void TWPartition::Process_FS_Flags(const char *str) {
832 char *options = strdup(str);
833 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800834
Matt Mower4ab42b12016-04-21 13:52:18 -0500835 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800836
Matt Mower4ab42b12016-04-21 13:52:18 -0500837 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600838 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
839 char *equals = strstr(ptr, "=");
840 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500841
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600842 if (!equals)
843 name_len = strlen(ptr);
844 else
845 name_len = equals - ptr;
846
847 // There are some flags that we want to ignore in TWRP
848 bool found_match = false;
849 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
850 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
851 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800852 break;
853 }
854 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600855 if (found_match)
856 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800857
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600858 // mount_flags are never postfixed by '='
859 if (!equals) {
860 const struct flag_list* mount_flag = mount_flags;
861 for (; mount_flag->name; mount_flag++) {
862 if (strcmp(ptr, mount_flag->name) == 0) {
863 if (mount_flag->flag == MS_RDONLY)
864 Mount_Read_Only = true;
865 else
866 Mount_Flags |= (unsigned)mount_flag->flag;
867 found_match = true;
868 break;
869 }
870 }
871 if (found_match)
872 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500873 }
874
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600875 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
876 if (!Mount_Options.empty())
877 Mount_Options += ",";
878 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500879 }
880 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800881}
882
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600883void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
884 partition_fs_flags_struct flags;
885 flags.File_System = local_File_System;
886 flags.Mount_Flags = local_Mount_Flags;
887 flags.Mount_Options = local_Mount_Options;
888 fs_flags.push_back(flags);
889}
890
Matt Mower2416a502016-04-12 19:54:46 -0500891void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
892 switch (flag) {
893 case TWFLAG_ANDSEC:
894 Has_Android_Secure = val;
895 break;
896 case TWFLAG_BACKUP:
897 Can_Be_Backed_Up = val;
898 break;
899 case TWFLAG_BACKUPNAME:
900 Backup_Display_Name = str;
901 break;
902 case TWFLAG_BLOCKSIZE:
903 Format_Block_Size = (unsigned long)(atol(str));
904 break;
905 case TWFLAG_CANBEWIPED:
906 Can_Be_Wiped = val;
907 break;
908 case TWFLAG_CANENCRYPTBACKUP:
909 Can_Encrypt_Backup = val;
910 break;
911 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600912 case TWFLAG_WAIT:
913 case TWFLAG_VERIFY:
914 case TWFLAG_CHECK:
915 case TWFLAG_NOTRIM:
916 case TWFLAG_VOLDMANAGED:
917 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500918 // Do nothing
919 break;
920 case TWFLAG_DISPLAY:
921 Display_Name = str;
922 break;
923 case TWFLAG_ENCRYPTABLE:
924 case TWFLAG_FORCEENCRYPT:
925 Crypto_Key_Location = str;
926 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500927 case TWFLAG_FILEENCRYPTION:
928 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
929 // fileencryption=ice:aes-256-heh
930 {
931 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500932 size_t colon_loc = FBE.find(":");
933 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500934 property_set("fbe.contents", FBE.c_str());
935 property_set("fbe.filenames", "");
936 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500937 break;
938 }
Ethan Yonker93382822018-11-01 15:25:31 -0500939 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500940 FBE_contents = FBE.substr(0, colon_loc);
941 FBE_filenames = FBE.substr(colon_loc + 1);
942 property_set("fbe.contents", FBE_contents.c_str());
943 property_set("fbe.filenames", FBE_filenames.c_str());
944 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
945 }
946 break;
Captain Throwbackf74fe4f2022-02-08 12:45:01 -0500947 case TWFLAG_METADATA_ENCRYPTION:
948 // This flag isn't used by TWRP but is needed for FBEv2 metadata decryption
949 // metadata_encryption=aes-256-xts:wrappedkey_v0
950 {
951 std::string META = str;
952 size_t colon_loc = META.find(":");
953 if (colon_loc == std::string::npos) {
954 property_set("metadata.contents", META.c_str());
955 property_set("metadata.filenames", "");
956 LOGINFO("Metadata contents '%s', filenames ''\n", META.c_str());
957 break;
958 }
959 std::string META_contents, META_filenames;
960 META_contents = META.substr(0, colon_loc);
961 META_filenames = META.substr(colon_loc + 1);
962 property_set("metadata.contents", META_contents.c_str());
963 property_set("metadata.filenames", META_filenames.c_str());
964 LOGINFO("Metadata contents '%s', filenames '%s'\n", META_contents.c_str(), META_filenames.c_str());
965 }
966 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800967 case TWFLAG_WRAPPEDKEY:
bigbiff437d86f2021-09-26 16:57:14 -0400968 // no more processing needed. leaving it here in case we want to do something in the future
Peter Cai28ea7b02019-05-24 11:38:54 +0800969 break;
Matt Mower2416a502016-04-12 19:54:46 -0500970 case TWFLAG_FLASHIMG:
971 Can_Flash_Img = val;
972 break;
973 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500974 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500975 break;
976 case TWFLAG_IGNOREBLKID:
977 Ignore_Blkid = val;
978 break;
979 case TWFLAG_LENGTH:
980 Length = atoi(str);
981 break;
982 case TWFLAG_MOUNTTODECRYPT:
983 Mount_To_Decrypt = val;
984 break;
Captain Throwback8d97d422022-02-08 15:31:44 -0500985 case TWFLAG_QUOTA:
986 // Filesystem flag - TWRP does not need to process
987 break;
Matt Mower2416a502016-04-12 19:54:46 -0500988 case TWFLAG_REMOVABLE:
989 Removable = val;
990 break;
Matt Mower2416a502016-04-12 19:54:46 -0500991 case TWFLAG_SETTINGSSTORAGE:
992 Is_Settings_Storage = val;
993 if (Is_Settings_Storage)
994 Is_Storage = true;
995 break;
996 case TWFLAG_STORAGE:
997 Is_Storage = val;
998 break;
999 case TWFLAG_STORAGENAME:
1000 Storage_Name = str;
1001 break;
1002 case TWFLAG_SUBPARTITIONOF:
1003 Is_SubPartition = true;
1004 SubPartition_Of = str;
1005 break;
1006 case TWFLAG_SYMLINK:
1007 Symlink_Path = str;
1008 break;
1009 case TWFLAG_USERDATAENCRYPTBACKUP:
1010 Use_Userdata_Encryption = val;
1011 if (Use_Userdata_Encryption)
1012 Can_Encrypt_Backup = true;
1013 break;
1014 case TWFLAG_USERMRF:
1015 Use_Rm_Rf = val;
1016 break;
1017 case TWFLAG_WIPEDURINGFACTORYRESET:
1018 Wipe_During_Factory_Reset = val;
1019 if (Wipe_During_Factory_Reset) {
1020 Can_Be_Wiped = true;
1021 Wipe_Available_in_GUI = true;
1022 }
1023 break;
1024 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001025 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -05001026 Wipe_Available_in_GUI = val;
1027 if (Wipe_Available_in_GUI)
1028 Can_Be_Wiped = true;
1029 break;
Ethan Yonker1b190162016-12-05 15:25:19 -06001030 case TWFLAG_SLOTSELECT:
1031 SlotSelect = true;
1032 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001033 case TWFLAG_ALTDEVICE:
1034 Alternate_Block_Device = str;
1035 break;
Peter Cai439d60c2019-10-17 08:49:10 +08001036 case TWFLAG_ADOPTED_MOUNT_DELAY:
1037 Adopted_Mount_Delay = atoi(str);
1038 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001039 case TWFLAG_KEYDIRECTORY:
1040 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001041 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001042 break;
Peter Caid68e6412019-11-02 19:22:38 +08001043 case TWFLAG_DM_USE_ORIGINAL_PATH:
1044 Use_Original_Path = true;
1045 break;
bigbiff998f8392021-08-06 19:19:33 -04001046 case TWFLAG_LOGICAL:
1047 Is_Super = true;
1048 break;
Matt Mower2416a502016-04-12 19:54:46 -05001049 default:
1050 // Should not get here
1051 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1052 break;
1053 }
1054}
Dees_Troy51127312012-09-08 13:08:49 -04001055
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001056void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001057 char separator[2] = {'\n', 0};
1058 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001059 char source_separator = ';';
1060
1061 if (fstab_ver == 2)
1062 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001063
1064 // Semicolons within double-quotes are not forbidden, so replace
1065 // only the semicolons intended as separators with '\n' for strtok
1066 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1067 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001068 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001069 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001070 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001071 }
1072
Matt Mower2416a502016-04-12 19:54:46 -05001073 // Avoid issues with potentially nested strtok by using strtok_r
1074 ptr = strtok_r(flags, separator, &savep);
1075 while (ptr) {
1076 int ptr_len = strlen(ptr);
1077 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001078
Matt Mower2416a502016-04-12 19:54:46 -05001079 for (; tw_flag->name; tw_flag++) {
1080 int flag_len = strlen(tw_flag->name);
1081
1082 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1083 bool flag_val = false;
1084
1085 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1086 && ptr[flag_len] != '=') {
1087 // Handle flags with same starting string
1088 // (e.g. backup and backupname)
1089 continue;
1090 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1091 // Handle flags with dual format: Part 1
1092 // (e.g. backup and backup=y. backup=y handled here)
1093 ptr += flag_len + 1;
1094 TWFunc::Strip_Quotes(ptr);
1095 // Skip flags with empty argument
1096 // (e.g. backup=)
1097 if (strlen(ptr) == 0) {
1098 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1099 break;
1100 }
1101 flag_val = strchr("yY1", *ptr) != NULL;
1102 } else if (ptr_len == flag_len
1103 && (tw_flag->name)[flag_len-1] == '=') {
1104 // Skip flags missing argument after =
1105 // (e.g. backupname=)
1106 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1107 break;
1108 } else if (ptr_len > flag_len
1109 && (tw_flag->name)[flag_len-1] == '=') {
1110 // Handle arguments to flags
1111 // (e.g. backupname="My Stuff")
1112 ptr += flag_len;
1113 TWFunc::Strip_Quotes(ptr);
1114 // Skip flags with empty argument
1115 // (e.g. backupname="")
1116 if (strlen(ptr) == 0) {
1117 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1118 break;
1119 }
1120 } else if (ptr_len == flag_len) {
1121 // Handle flags with dual format: Part 2
1122 // (e.g. backup and backup=y. backup handled here)
1123 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001124 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001125 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1126 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001127 }
Matt Mower2416a502016-04-12 19:54:46 -05001128
1129 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1130 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001131 }
Matt Mower2416a502016-04-12 19:54:46 -05001132 }
1133 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001134 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001135 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001136 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001137 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001138 }
Matt Mower2416a502016-04-12 19:54:46 -05001139 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001140 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001141}
1142
Dees_Troy5bf43922012-09-07 16:07:55 -04001143bool TWPartition::Is_File_System(string File_System) {
1144 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001145 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001146 File_System == "ext4" ||
1147 File_System == "vfat" ||
1148 File_System == "ntfs" ||
1149 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001150 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001151 File_System == "f2fs" ||
GarfieldHanc60a2082021-11-21 23:46:20 +08001152 File_System == "erofs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001153 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001154 File_System == "auto")
1155 return true;
1156 else
1157 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001158}
1159
Dees_Troy5bf43922012-09-07 16:07:55 -04001160bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001161 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001162 return true;
1163 else
1164 return false;
1165}
1166
Dees_Troy51127312012-09-08 13:08:49 -04001167bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001168 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1169 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001170 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001171 if (mkdir(Path.c_str(), 0777) == -1) {
1172 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001173 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001174 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001175 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001176 return false;
1177 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001178 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001179 return true;
1180 }
1181 }
1182 return true;
1183}
1184
Dees_Troy5bf43922012-09-07 16:07:55 -04001185void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001186 Can_Be_Mounted = true;
1187 Can_Be_Wiped = true;
1188
Dees_Troy5bf43922012-09-07 16:07:55 -04001189 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001190 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001191 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001192}
1193
Ethan Yonker1b190162016-12-05 15:25:19 -06001194void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001195 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1196 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001197 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001198 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001199 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001200 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001201 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001202 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 -04001203}
1204
Dees_Troye58d5262012-09-21 12:27:57 -04001205void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001206 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001207 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001208 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001209 Has_Android_Secure = true;
1210 Symlink_Path = Mount_Point + "/.android_secure";
1211 Symlink_Mount_Point = "/and-sec";
1212 Backup_Path = Symlink_Mount_Point;
1213 Make_Dir("/and-sec", true);
1214 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001215 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001216}
1217
that9e0593e2014-10-08 00:01:24 +02001218void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001219 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001220 if (Storage_Name.empty() || Storage_Name == "Data")
1221 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001222 Has_Data_Media = true;
1223 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001224 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001225 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001226 if (Mount_Point == "/data") {
1227 Is_Settings_Storage = true;
1228 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1229 Make_Dir("/emmc", false);
1230 Symlink_Mount_Point = "/emmc";
1231 } else {
1232 Make_Dir("/sdcard", false);
1233 Symlink_Mount_Point = "/sdcard";
1234 }
bigbiff4fa02b52021-12-30 17:01:44 -05001235 Mount(false);
1236 if (TWFunc::Path_Exists(Mount_Point + "/media/0")) {
Ethan Yonker66a19492015-12-10 10:19:45 -06001237 Storage_Path = Mount_Point + "/media/0";
1238 Symlink_Path = Storage_Path;
1239 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1240 UnMount(true);
1241 }
1242 DataManager::SetValue("tw_has_internal", 1);
1243 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001244 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001245 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 +01001246 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001247 backup_exclusions.add_absolute_dir("/data/cache");
nijel87e5bc9b2022-01-14 10:01:32 -05001248 backup_exclusions.add_absolute_dir("/data/misc/apexdata/com.android.art"); // exclude this dir to prevent "error 255" on AOSP Android 12
sekaiacg05ca8762022-07-06 11:19:45 +08001249 backup_exclusions.add_absolute_dir("/data/extm"); //exclude this dir to prevent "error 255" on MIUI
Ethan Yonker6355b562017-05-01 09:42:17 -05001250 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001251 ExcludeAll(Mount_Point + "/system/storage.xml");
Darth9cc683e72022-08-09 12:54:40 +01001252
1253 // board-customisable exclusions
1254 #ifdef TW_BACKUP_EXCLUSIONS
1255 std::vector<std::string> user_extra_exclusions = TWFunc::Split_String(TW_BACKUP_EXCLUSIONS, ",");
1256 std::string s1;
1257 for (const std::string& extra_x : user_extra_exclusions) {
1258 s1 = android::base::Trim(extra_x);
1259 if (!s1.empty()) {
1260 backup_exclusions.add_absolute_dir(s1);
1261 LOGINFO("Adding user-defined path '%s' to the backup exclusions\n", s1.c_str());
1262 }
1263 }
1264 #endif
Ethan Yonker6277c792014-09-15 14:54:30 -05001265 } else {
nkk717aa6fc62017-03-24 18:28:03 +02001266 int i;
1267 string path;
1268 for (i = 2; i <= 9; i++) {
1269 path = "/sdcard" + TWFunc::to_string(i);
1270 if (!TWFunc::Path_Exists(path)) {
1271 Make_Dir(path, false);
1272 Symlink_Mount_Point = path;
1273 LOGINFO("'%s' data/media emulated storage symlinked to %s.\n", Mount_Point.c_str(), Symlink_Mount_Point.c_str());
1274 break;
1275 }
1276 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001277 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1278 Storage_Path = Mount_Point + "/media/0";
1279 Symlink_Path = Storage_Path;
1280 UnMount(true);
1281 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001282 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001283 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001284}
1285
Dees_Troy5bf43922012-09-07 16:07:55 -04001286void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001287 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001288
Peter Caid68e6412019-11-02 19:22:38 +08001289 Original_Path = Block;
1290
Dees_Troy5bf43922012-09-07 16:07:55 -04001291 strcpy(device, Block.c_str());
1292 memset(realDevice, 0, sizeof(realDevice));
1293 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1294 {
1295 strcpy(device, realDevice);
1296 memset(realDevice, 0, sizeof(realDevice));
1297 }
1298
bigbiff998f8392021-08-06 19:19:33 -04001299 Block = device;
1300 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001301}
1302
Kjell Braden3126a112016-06-19 16:58:15 +00001303bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001304 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001305 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001306 int retry_count = 5;
1307 while (retry_count > 0 && !Mount(false)) {
1308 usleep(500000);
1309 retry_count--;
1310 }
Kjell Braden3126a112016-06-19 16:58:15 +00001311 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001312 }
Kjell Braden3126a112016-06-19 16:58:15 +00001313 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001314}
1315
Dees_Troy38bd7602012-09-14 13:33:53 -04001316bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1317 FILE *fp = NULL;
1318 char line[255];
1319
1320 fp = fopen("/proc/mtd", "rt");
1321 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001322 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001323 return false;
1324 }
1325
1326 while (fgets(line, sizeof(line), fp) != NULL)
1327 {
1328 char device[32], label[32];
1329 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001330 int deviceId;
1331
1332 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1333
1334 // Skip header and blank lines
1335 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1336 continue;
1337
1338 // Strip off the trailing " from the label
1339 label[strlen(label)-1] = '\0';
1340
1341 if (strcmp(label, MTD_Name.c_str()) == 0) {
1342 // We found our device
1343 // Strip off the trailing : from the device
1344 device[strlen(device)-1] = '\0';
1345 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1346 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1347 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001348 fclose(fp);
1349 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001350 }
1351 }
1352 }
1353 fclose(fp);
1354
1355 return false;
1356}
1357
Dees_Troy51127312012-09-08 13:08:49 -04001358bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1359 struct statfs st;
1360 string Local_Path = Mount_Point + "/.";
1361
1362 if (!Mount(Display_Error))
1363 return false;
1364
1365 if (statfs(Local_Path.c_str(), &st) != 0) {
1366 if (!Removable) {
1367 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001368 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001369 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001370 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001371 }
1372 return false;
1373 }
1374 Size = (st.f_blocks * st.f_bsize);
1375 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1376 Free = (st.f_bfree * st.f_bsize);
1377 Backup_Size = Used;
1378 return true;
1379}
1380
1381bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001382 FILE* fp;
1383 char command[255], line[512];
1384 int include_block = 1;
1385 unsigned int min_len;
1386
1387 if (!Mount(Display_Error))
1388 return false;
1389
Dees_Troy38bd7602012-09-14 13:33:53 -04001390 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001391 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001392 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001393 fp = fopen("/tmp/dfoutput.txt", "rt");
1394 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001395 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001396 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001397 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001398
1399 while (fgets(line, sizeof(line), fp) != NULL)
1400 {
1401 unsigned long blocks, used, available;
1402 char device[64];
1403 char tmpString[64];
1404
1405 if (strncmp(line, "Filesystem", 10) == 0)
1406 continue;
1407 if (strlen(line) < min_len) {
1408 include_block = 0;
1409 continue;
1410 }
1411 if (include_block) {
1412 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1413 } else {
1414 // The device block string is so long that the df information is on the next line
1415 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001416 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001417 while (tmpString[space_count] == 32)
1418 space_count++;
1419 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1420 }
1421
1422 // Adjust block size to byte size
1423 Size = blocks * 1024ULL;
1424 Used = used * 1024ULL;
1425 Free = available * 1024ULL;
1426 Backup_Size = Used;
1427 }
1428 fclose(fp);
1429 return true;
1430}
1431
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001432unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001433 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001434
1435 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001436}
1437
Dees_Troy5bf43922012-09-07 16:07:55 -04001438bool TWPartition::Find_Partition_Size(void) {
1439 FILE* fp;
1440 char line[512];
1441 string tmpdevice;
1442
igoriok87e3d932013-01-31 21:03:53 +02001443 fp = fopen("/proc/dumchar_info", "rt");
1444 if (fp != NULL) {
1445 while (fgets(line, sizeof(line), fp) != NULL)
1446 {
1447 char label[32], device[32];
1448 unsigned long size = 0;
1449
thatd43bf2d2014-09-21 23:13:02 +02001450 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001451
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001452 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001453 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1454 continue;
1455
1456 tmpdevice = "/dev/";
1457 tmpdevice += label;
1458 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1459 Size = size;
1460 fclose(fp);
1461 return true;
1462 }
1463 }
1464 }
1465
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001466 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1467 if (ioctl_size) {
1468 Size = ioctl_size;
1469 return true;
1470 }
1471
Dees_Troy5bf43922012-09-07 16:07:55 -04001472 // In this case, we'll first get the partitions we care about (with labels)
1473 fp = fopen("/proc/partitions", "rt");
1474 if (fp == NULL)
1475 return false;
1476
1477 while (fgets(line, sizeof(line), fp) != NULL)
1478 {
1479 unsigned long major, minor, blocks;
1480 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001481
Dees_Troy63c8df72012-09-10 14:02:05 -04001482 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001483 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1484
1485 tmpdevice = "/dev/block/";
1486 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001487 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001488 // Adjust block size to byte size
1489 Size = blocks * 1024ULL;
1490 fclose(fp);
1491 return true;
1492 }
1493 }
1494 fclose(fp);
1495 return false;
1496}
1497
Dees_Troy5bf43922012-09-07 16:07:55 -04001498bool TWPartition::Is_Mounted(void) {
1499 if (!Can_Be_Mounted)
1500 return false;
1501
1502 struct stat st1, st2;
1503 string test_path;
1504
1505 // Check to see if the mount point directory exists
1506 test_path = Mount_Point + "/.";
1507 if (stat(test_path.c_str(), &st1) != 0) return false;
1508
1509 // Check to see if the directory above the mount point exists
1510 test_path = Mount_Point + "/../.";
1511 if (stat(test_path.c_str(), &st2) != 0) return false;
1512
1513 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1514 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001515 return ret;
1516}
1517
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001518bool TWPartition::Is_File_System_Writable(void) {
1519 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1520 return false;
1521
1522 string test_path = Mount_Point + "/.";
1523 return (access(test_path.c_str(), W_OK) == 0);
1524}
1525
Dees_Troy5bf43922012-09-07 16:07:55 -04001526bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001527 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001528 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001529
Dees_Troy5bf43922012-09-07 16:07:55 -04001530 if (Is_Mounted()) {
1531 return true;
1532 } else if (!Can_Be_Mounted) {
1533 return false;
1534 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001535
1536 Find_Actual_Block_Device();
1537
1538 // Check the current file system before mounting
1539 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001540 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1541 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 +00001542 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001543 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001544 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001545 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001546 Current_File_System = "vfat";
1547 } else {
1548#ifdef TW_NO_EXFAT_FUSE
1549 UnMount(false);
1550 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1551 // Some kernels let us mount vfat as exfat which doesn't work out too well
1552#else
1553 exfat_mounted = 1;
1554#endif
1555 }
1556 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001557
Captain Throwback47bf7202020-10-06 17:39:39 -04001558 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 -05001559 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001560 string Ntfsmount_Binary = "";
1561
bigbiffad58e1b2020-07-06 20:24:34 -04001562 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001563 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001564 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001565 Ntfsmount_Binary = "mount.ntfs";
1566
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001567 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001568 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001569 else
bigbiffad58e1b2020-07-06 20:24:34 -04001570 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001571 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001572
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001573 if (TWFunc::Exec_Cmd(cmd) == 0) {
1574 return true;
1575 } else {
1576 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1577 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001578 } else {
1579 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1580 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001581 }
1582
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001583 if (Mount_Read_Only)
1584 flags |= MS_RDONLY;
1585
Dees_Troy22042032012-12-18 21:23:08 +00001586 if (Fstab_File_System == "yaffs2") {
1587 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001588 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1589 if (Mount_Read_Only)
1590 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001591 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1592 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1593 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001594 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001595 else
1596 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1597 return false;
1598 } else {
1599 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1600 return true;
1601 }
1602 } else {
1603 struct stat st;
1604 string test_path = Mount_Point;
1605 if (stat(test_path.c_str(), &st) < 0) {
1606 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001607 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001608 else
1609 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1610 return false;
1611 }
1612 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1613 if (new_mode != st.st_mode) {
1614 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1615 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1616 if (Display_Error)
1617 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1618 else
1619 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1620 return false;
1621 }
1622 }
Dees_Troy22042032012-12-18 21:23:08 +00001623 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001624 }
thatc7572eb2015-03-31 18:55:30 +02001625 }
1626
1627 string mount_fs = Current_File_System;
1628 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1629 mount_fs = "texfat";
1630
1631 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001632 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1633 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001634#ifdef TW_NO_EXFAT_FUSE
1635 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001636 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001637 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001638 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001639 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001640 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001641 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001642 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 +00001643 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001644 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001645 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001646#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001647 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001648 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001649 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001650 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1651 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 +00001652 return false;
1653#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001654 }
1655#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001656 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001657
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001658 if (Removable)
1659 Update_Size(Display_Error);
1660
bigbiff4fa02b52021-12-30 17:01:44 -05001661 if (!Symlink_Mount_Point.empty()) {
bigbiffbe4f46c2021-04-24 11:48:54 -04001662 if (!Bind_Mount(false))
1663 return false;
1664 }
1665 return true;
1666}
1667
1668bool TWPartition::Bind_Mount(bool Display_Error) {
1669 if (TWFunc::Path_Exists(Symlink_Path)) {
1670 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1671 return false;
1672 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001673 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001674 return true;
1675}
1676
1677bool TWPartition::UnMount(bool Display_Error) {
1678 if (Is_Mounted()) {
1679 int never_unmount_system;
1680
1681 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001682 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001683 return true; // Never unmount system if you're not supposed to unmount it
1684
Matt Mowera8e6d832017-02-14 20:20:59 -06001685 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001686 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001687
Dees_Troy38bd7602012-09-14 13:33:53 -04001688 if (!Symlink_Mount_Point.empty())
1689 umount(Symlink_Mount_Point.c_str());
1690
Dees_Troyb05ddee2013-01-28 20:24:50 +00001691 umount(Mount_Point.c_str());
1692 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001693 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001694 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001695 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001696 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001697 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001698 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001699 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001700 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001701 } else {
1702 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001703 }
1704}
1705
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001706bool TWPartition::ReMount(bool Display_Error) {
1707 if (UnMount(Display_Error))
1708 return Mount(Display_Error);
1709 return false;
1710}
1711
1712bool TWPartition::ReMount_RW(bool Display_Error) {
1713 // No need to remount if already mounted rw
1714 if (Is_File_System_Writable())
1715 return true;
1716
1717 bool ro = Mount_Read_Only;
1718 int flags = Mount_Flags;
1719
1720 Mount_Read_Only = false;
1721 Mount_Flags &= ~MS_RDONLY;
1722
1723 bool ret = ReMount(Display_Error);
1724
1725 Mount_Read_Only = ro;
1726 Mount_Flags = flags;
1727
1728 return ret;
1729}
1730
Gary Peck43acadf2012-11-21 21:19:01 -08001731bool TWPartition::Wipe(string New_File_System) {
bigbiff7df87472022-09-24 16:45:03 -04001732 bool wiped = false, update_crypt = false, recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001733 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001734
Dees_Troy38bd7602012-09-14 13:33:53 -04001735 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001736 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001737 return false;
1738 }
1739
Dees_Troyc51f1f92012-09-20 15:32:13 -04001740 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001741 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001742
bigbiff4a60bee2021-01-23 14:08:03 -05001743 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1744 if (tw_get_default_metadata(PartitionManager.Get_Android_Root_Path().c_str()) != 0) {
1745 gui_msg(Msg(msg::kWarning, "restore_system_context=Unable to get default context for {1} -- Android may not boot.")(PartitionManager.Get_Android_Root_Path()));
1746 }
1747 }
1748
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001749 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001750 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001751 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1752 bool created = PartitionManager.Recreate_Logs_Dir();
1753 if (!created)
1754 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001755 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001756 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001757 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001758 DataManager::GetValue(TW_RM_RF_VAR, check);
Hashcodedabfd492013-08-29 22:45:30 -07001759 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001760 wiped = Wipe_RMRF();
1761 else if (New_File_System == "ext4")
1762 wiped = Wipe_EXT4();
1763 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001764 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001765 else if (New_File_System == "exfat")
1766 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001767 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1768 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001769 else if (New_File_System == "yaffs2")
1770 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001771 else if (New_File_System == "f2fs")
1772 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001773 else if (New_File_System == "vfat")
1774 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001775 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001776 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 +00001777 return false;
1778 }
1779 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001780 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001781 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001782
Gary Pecke8bc5d72012-12-21 06:45:25 -08001783 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301784 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1785 DataManager::Output_Version();
1786
bigbiff4a60bee2021-01-23 14:08:03 -05001787 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1788 tw_set_default_metadata(PartitionManager.Get_Android_Root_Path().c_str());
1789 }
Dees_Troy16c2b312013-01-15 16:51:18 +00001790 if (update_crypt) {
1791 Setup_File_System(false);
1792 if (Is_Encrypted && !Is_Decrypted) {
1793 // just wiped an encrypted partition back to its unencrypted state
1794 Is_Encrypted = false;
1795 Is_Decrypted = false;
1796 Decrypted_Block_Device = "";
1797 if (Mount_Point == "/data") {
1798 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1799 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1800 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001801 }
1802 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001803
Captain Throwback63573b52021-10-02 20:47:33 -04001804 if (Is_Storage && Mount(false) && !Is_FBE)
bigbiffbe4f46c2021-04-24 11:48:54 -04001805 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001806 }
Matt Mower209c9632016-01-20 12:08:35 -06001807
Gary Pecke8bc5d72012-12-21 06:45:25 -08001808 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001809}
1810
Gary Peck43acadf2012-11-21 21:19:01 -08001811bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001812 if (Is_File_System(Current_File_System))
1813 return Wipe(Current_File_System);
1814 else
1815 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001816}
1817
Dees_Troye58d5262012-09-21 12:27:57 -04001818bool TWPartition::Wipe_AndSec(void) {
1819 if (!Has_Android_Secure)
1820 return false;
1821
Dees_Troye58d5262012-09-21 12:27:57 -04001822 if (!Mount(true))
1823 return false;
1824
Ethan Yonker74db1572015-10-28 12:44:49 -05001825 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001826 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001827 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001828}
1829
bigbiffaed1bdf2021-08-03 18:21:39 -04001830bool TWPartition::Wipe_Data_Cache(void) {
1831 if (!Mount(true))
1832 return false;
1833 gui_msg(Msg("wiping=Wiping {1}")(Mount_Point + "/cache/"));
1834 TWFunc::removeDir(Mount_Point + "/cache/", true);
1835 return true;
1836}
1837
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001838bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001839 if (Mount_Read_Only)
1840 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001841 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/system/bin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001842 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001843 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 -05001844 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001845 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/fsck.exfat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001846 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001847 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/system/bin/fsck.f2fs"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001848 return true;
Captain Throwback47bf7202020-10-06 17:39:39 -04001849 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 -05001850 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001851 return false;
1852}
1853
1854bool TWPartition::Repair() {
1855 string command;
1856
1857 if (Current_File_System == "vfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001858 if (!TWFunc::Path_Exists("/system/bin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001859 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001860 return false;
1861 }
1862 if (!UnMount(true))
1863 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001864 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001865 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001866 command = "/system/bin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001867 LOGINFO("Repair command: %s\n", command.c_str());
1868 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001869 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001870 return true;
1871 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001872 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001873 return false;
1874 }
1875 }
1876 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
bigbiffad58e1b2020-07-06 20:24:34 -04001877 if (!TWFunc::Path_Exists("/system/bin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001878 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001879 return false;
1880 }
1881 if (!UnMount(true))
1882 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001883 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001884 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001885 command = "/system/bin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001886 LOGINFO("Repair command: %s\n", command.c_str());
1887 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001888 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001889 return true;
1890 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001891 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001892 return false;
1893 }
1894 }
1895 if (Current_File_System == "exfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001896 if (!TWFunc::Path_Exists("/system/bin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001897 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001898 return false;
1899 }
1900 if (!UnMount(true))
1901 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001902 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001903 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001904 command = "/system/bin/fsck.exfat " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001905 LOGINFO("Repair command: %s\n", command.c_str());
1906 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001907 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001908 return true;
1909 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001910 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001911 return false;
1912 }
1913 }
1914 if (Current_File_System == "f2fs") {
bigbiffad58e1b2020-07-06 20:24:34 -04001915 if (!TWFunc::Path_Exists("/system/bin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001916 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001917 return false;
1918 }
1919 if (!UnMount(true))
1920 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001921 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001922 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001923 command = "/system/bin/fsck.f2fs " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001924 LOGINFO("Repair command: %s\n", command.c_str());
1925 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001926 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001927 return true;
1928 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001929 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001930 return false;
1931 }
1932 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001933 if (Current_File_System == "ntfs" || Current_File_System == "tntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001934 string Ntfsfix_Binary;
bigbiffad58e1b2020-07-06 20:24:34 -04001935 if (TWFunc::Path_Exists("/system/bin/ntfsfix"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001936 Ntfsfix_Binary = "ntfsfix";
bigbiffad58e1b2020-07-06 20:24:34 -04001937 else if (TWFunc::Path_Exists("/system/bin/fsck.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001938 Ntfsfix_Binary = "fsck.ntfs";
1939 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001940 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001941 return false;
1942 }
1943 if (!UnMount(true))
1944 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001945 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001946 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001947 command = "/system/bin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001948 LOGINFO("Repair command: %s\n", command.c_str());
1949 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001950 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001951 return true;
1952 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001953 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001954 return false;
1955 }
1956 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001957 return false;
1958}
1959
Ethan Yonkera2719152015-05-28 09:44:41 -05001960bool TWPartition::Can_Resize() {
1961 if (Mount_Read_Only)
1962 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001963 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 -05001964 return true;
1965 return false;
1966}
1967
1968bool TWPartition::Resize() {
1969 string command;
1970
1971 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1972 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001973 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1974 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001975 return false;
1976 }
bigbiffad58e1b2020-07-06 20:24:34 -04001977 if (!TWFunc::Path_Exists("/system/bin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001978 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1979 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001980 return false;
1981 }
1982 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001983 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001984 if (!Repair())
1985 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001986 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001987 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001988 command = "/system/bin/resize2fs " + Actual_Block_Device;
Ethan Yonkera2719152015-05-28 09:44:41 -05001989 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001990 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1991 if (Actual_Size == 0)
1992 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001993
Ethan Yonkera2719152015-05-28 09:44:41 -05001994 unsigned long long Block_Count;
1995 if (Length < 0) {
1996 // Reduce overall size by this length
1997 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1998 } else {
1999 // This is the size, not a size reduction
2000 Block_Count = ((unsigned long long)(Length) / 1024LLU);
2001 }
2002 char temp[256];
2003 sprintf(temp, "%llu", Block_Count);
2004 command += " ";
2005 command += temp;
2006 command += "K";
2007 }
2008 LOGINFO("Resize command: %s\n", command.c_str());
2009 if (TWFunc::Exec_Cmd(command) == 0) {
2010 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05002011 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05002012 return true;
2013 } else {
2014 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05002015 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05002016 return false;
2017 }
2018 }
2019 return false;
2020}
2021
bigbiffce8f83c2015-12-12 18:30:21 -05002022bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
2023 if (Backup_Method == BM_FILES)
2024 return Backup_Tar(part_settings, tar_fork_pid);
2025 else if (Backup_Method == BM_DD)
2026 return Backup_Image(part_settings);
2027 else if (Backup_Method == BM_FLASH_UTILS)
2028 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00002029 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002030 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002031}
2032
bigbiffce8f83c2015-12-12 18:30:21 -05002033bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06002034 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002035 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08002036
bigbiffce8f83c2015-12-12 18:30:21 -05002037 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002038
2039 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05002040 return Restore_Tar(part_settings);
2041 else if (Is_Image(Restore_File_System))
2042 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002043
2044 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
2045 return false;
2046}
2047
bigbiffce8f83c2015-12-12 18:30:21 -05002048string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002049 size_t first_period, second_period;
2050 string Restore_File_System;
2051
Gary Peck43acadf2012-11-21 21:19:01 -08002052 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002053 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08002054 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002055 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002056 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002057 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002058 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08002059 second_period = Restore_File_System.find(".");
2060 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002061 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002062 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002063 }
2064 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06002065 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002066 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04002067}
2068
2069string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05002070 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04002071 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05002072 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04002073 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05002074 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04002075 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05002076 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04002077 return "flash_utils";
2078 else
2079 return "undefined";
2080 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04002081}
2082
2083bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002084 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002085 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04002086 return 1;
2087}
2088
2089bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002090 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05002091 bool ret = false;
2092 BasePartition* base_partition = make_partition();
2093
2094 if (!base_partition->PreWipeEncryption())
2095 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002096
dianlujitao4879b372018-12-03 18:45:47 +08002097 Find_Actual_Block_Device();
2098 if (!Is_Present) {
2099 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
2100 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2101 return false;
2102 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002103
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002104#ifdef TW_INCLUDE_CRYPTO
bigbiff7ba75002020-04-11 20:47:09 -04002105 if (!UnMount(true))
2106 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002107 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06002108 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002109 LOGERR("Error deleting crypto block device, continuing anyway.\n");
2110 }
2111 }
2112#endif
dianlujitao4879b372018-12-03 18:45:47 +08002113 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05002114 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00002115 Is_Decrypted = false;
2116 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08002117 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002118 Has_Data_Media = Save_Data_Media;
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002119 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05002120#ifndef TW_OEM_BUILD
bigbiff25d25b92020-06-19 16:07:38 -04002121 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 -05002122#endif
bigbiff2d548672021-07-09 20:08:44 -04002123 if (Is_FBE) {
2124 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 -04002125 } else {
2126 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
2127 if (Mount(false))
2128 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2129 }
bigbiff2d548672021-07-09 20:08:44 -04002130 }
2131
Ethan Yonker93382822018-11-01 15:25:31 -05002132 ret = true;
2133 if (!Key_Directory.empty())
2134 ret = PartitionManager.Wipe_By_Path(Key_Directory);
2135 if (ret)
2136 ret = base_partition->PostWipeEncryption();
2137 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002138 } else {
2139 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05002140 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06002141 if (Has_Data_Media && Mount(false))
2142 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05002143 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002144 }
Ethan Yonker93382822018-11-01 15:25:31 -05002145exit:
2146 delete base_partition;
2147 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002148}
2149
2150void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002151 const char* type;
2152 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04002153
Dees_Troy68cab492012-12-12 19:29:35 +00002154 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
2155 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04002156
Dees_Troy38bd7602012-09-14 13:33:53 -04002157 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04002158 if (!Is_Present)
2159 return;
Dees_Troy51127312012-09-08 13:08:49 -04002160
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002161 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2162 if (blkid_do_fullprobe(pr)) {
2163 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002164 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002165 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002166 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002167
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002168 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002169 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002170 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002171 return;
2172 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002173
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002174 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002175 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002176 if (fs_flags.size() > 1) {
2177 std::vector<partition_fs_flags_struct>::iterator iter;
2178 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2179
2180 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2181 if (iter->File_System == Current_File_System) {
2182 found = iter;
2183 break;
2184 }
2185 }
2186 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2187 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2188 Mount_Flags = found->Mount_Flags;
2189 Mount_Options = found->Mount_Options;
2190 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2191 }
2192 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002193}
2194
dianlujitao4879b372018-12-03 18:45:47 +08002195bool TWPartition::Wipe_EXTFS(string File_System) {
bigbiff7ba75002020-04-11 20:47:09 -04002196 if (!UnMount(true))
2197 return false;
2198
dianlujitao4879b372018-12-03 18:45:47 +08002199#if PLATFORM_SDK_VERSION < 28
bigbiffad58e1b2020-07-06 20:24:34 -04002200 if (!TWFunc::Path_Exists("/system/bin/mke2fs"))
dianlujitao4879b372018-12-03 18:45:47 +08002201#else
bigbiffad58e1b2020-07-06 20:24:34 -04002202 if (!TWFunc::Path_Exists("/system/bin/mke2fs") || !TWFunc::Path_Exists("/system/bin/e2fsdroid"))
dianlujitao4879b372018-12-03 18:45:47 +08002203#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002204 return Wipe_RMRF();
2205
dianlujitao4879b372018-12-03 18:45:47 +08002206 int ret;
2207 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002208
Ethan Yonker25f20c12014-10-14 09:04:43 -05002209 Find_Actual_Block_Device();
2210 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002211 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2212 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002213 return false;
2214 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002215
dianlujitao4879b372018-12-03 18:45:47 +08002216 /**
2217 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2218 * so there's no need to preserve footer.
2219 */
2220 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2221 Crypto_Key_Location != "footer") {
2222 NeedPreserveFooter = false;
2223 }
2224
2225 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2226 if (!dev_sz)
2227 return false;
2228
2229 if (NeedPreserveFooter)
2230 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2231
Dees Troy9a4d7402019-03-21 14:17:28 -04002232 char dout[16];
2233 sprintf(dout, "%llu", dev_sz / 4096);
2234
2235 //string size_str =to_string(dev_sz / 4096);
2236 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002237 string Command;
2238
2239 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2240
2241 // Execute mke2fs to create empty ext4 filesystem
2242 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2243 LOGINFO("mke2fs command: %s\n", Command.c_str());
2244 ret = TWFunc::Exec_Cmd(Command);
2245 if (ret) {
2246 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2247 return false;
2248 }
2249
bigbiffad58e1b2020-07-06 20:24:34 -04002250 if (TWFunc::Path_Exists("/system/bin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002251 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2252 char *secontext = NULL;
2253 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2254 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2255 } else {
2256 // Execute e2fsdroid to initialize selinux context
bigbiff5b911ca2020-07-18 10:46:09 -04002257 if (Mount_Point == "/persist") {
2258 Mount(true);
2259 TWFunc::removeDir("/persist/lost+found", false);
2260 UnMount(true);
2261 }
dianlujitao3cf05a52019-05-15 15:33:27 +08002262 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2263 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2264 ret = TWFunc::Exec_Cmd(Command);
2265 if (ret) {
2266 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2267 return false;
2268 }
dianlujitao4879b372018-12-03 18:45:47 +08002269 }
2270 } else {
2271 LOGINFO("e2fsdroid not present\n");
2272 }
2273
2274 if (NeedPreserveFooter)
2275 Wipe_Crypto_Key();
2276 Current_File_System = File_System;
2277 Recreate_AndSec_Folder();
2278 gui_msg("done=Done.");
2279 return true;
2280}
2281
2282bool TWPartition::Wipe_EXT4() {
2283#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002284 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002285 bool NeedPreserveFooter = true;
2286
bigbiff7ba75002020-04-11 20:47:09 -04002287 if (!UnMount(true))
2288 return false;
2289
dianlujitao4879b372018-12-03 18:45:47 +08002290 Find_Actual_Block_Device();
2291 if (!Is_Present) {
2292 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2293 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2294 return false;
2295 }
dianlujitao4879b372018-12-03 18:45:47 +08002296
2297 /**
2298 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2299 * so there's no need to preserve footer.
2300 */
2301 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2302 Crypto_Key_Location != "footer") {
2303 NeedPreserveFooter = false;
2304 }
2305
2306 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2307 if (!dev_sz)
2308 return false;
2309
2310 if (NeedPreserveFooter)
2311 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2312
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002313 char *secontext = NULL;
2314
Greg Wallace4b44fef2015-12-29 15:33:24 -05002315 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002316
Dees Troy99c8dbf2014-03-10 16:53:58 +00002317 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002318 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002319 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002320 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002321 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002322 }
2323 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002324 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002325 return false;
2326 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002327 if (NeedPreserveFooter)
2328 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002329 string sedir = Mount_Point + "/lost+found";
2330 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2331 rmdir(sedir.c_str());
2332 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002333 return true;
2334 }
2335#else
dianlujitao4879b372018-12-03 18:45:47 +08002336 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002337#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002338}
2339
2340bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002341 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002342
bigbiff7ba75002020-04-11 20:47:09 -04002343 if (!UnMount(true))
2344 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002345
bigbiffad58e1b2020-07-06 20:24:34 -04002346 if (TWFunc::Path_Exists("/system/bin/mkfs.fat")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002347 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002348 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002349 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002350 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002351 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002352 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002353 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002354 return true;
2355 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002356 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002357 return false;
2358 }
2359 return true;
2360 }
2361 else
2362 return Wipe_RMRF();
2363
2364 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002365}
2366
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002367bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002368 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002369
bigbiff7ba75002020-04-11 20:47:09 -04002370 if (!UnMount(true))
2371 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002372 if (TWFunc::Path_Exists("/system/bin/mkexfatfs")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002373 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002374 Find_Actual_Block_Device();
2375 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002376 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002377 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002378 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002379 return true;
2380 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002381 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002382 return false;
2383 }
2384 return true;
2385 }
2386 return false;
2387}
2388
Dees_Troy38bd7602012-09-14 13:33:53 -04002389bool TWPartition::Wipe_MTD() {
2390 if (!UnMount(true))
2391 return false;
2392
Greg Wallace4b44fef2015-12-29 15:33:24 -05002393 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002394
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002395 mtd_scan_partitions();
2396 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2397 if (mtd == NULL) {
2398 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2399 return false;
2400 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002401
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002402 MtdWriteContext* ctx = mtd_write_partition(mtd);
2403 if (ctx == NULL) {
2404 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2405 return false;
2406 }
2407 if (mtd_erase_blocks(ctx, -1) == -1) {
2408 mtd_write_close(ctx);
2409 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2410 return false;
2411 }
2412 if (mtd_write_close(ctx) != 0) {
2413 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2414 return false;
2415 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002416 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002417 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002418 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002419 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002420}
2421
2422bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002423 if (!Mount(true))
2424 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002425 // This is the only wipe that leaves the partition mounted, so we
2426 // must manually remove the partition from MTP if it is a storage
2427 // partition.
2428 if (Is_Storage)
2429 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002430
Ethan Yonker74db1572015-10-28 12:44:49 -05002431 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002432 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002433 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002434 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002435}
2436
Dees_Troye5017042013-08-29 16:38:55 +00002437bool TWPartition::Wipe_F2FS() {
systemaddb475c92021-08-12 20:33:20 +02002438 std::string f2fs_command;
Dees_Troye5017042013-08-29 16:38:55 +00002439
bigbiff7ba75002020-04-11 20:47:09 -04002440 if (!UnMount(true))
2441 return false;
dianlujitao4879b372018-12-03 18:45:47 +08002442
bigbiffad58e1b2020-07-06 20:24:34 -04002443 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002444 f2fs_command = "/system/bin/mkfs.f2fs";
bigbiffad58e1b2020-07-06 20:24:34 -04002445 else if (TWFunc::Path_Exists("/system/bin/make_f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002446 f2fs_command = "/system/bin/make_f2fs -g android";
bigbiff7ba75002020-04-11 20:47:09 -04002447 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002448 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002449 return Wipe_RMRF();
2450 }
bigbiff7ba75002020-04-11 20:47:09 -04002451
2452 bool NeedPreserveFooter = true;
systemaddb475c92021-08-12 20:33:20 +02002453 bool needs_casefold = false;
2454 bool needs_projid = false;
bigbiff7ba75002020-04-11 20:47:09 -04002455
2456 Find_Actual_Block_Device();
2457 if (!Is_Present) {
2458 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2459 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2460 return false;
2461 }
systemaddb475c92021-08-12 20:33:20 +02002462
2463 needs_casefold = android::base::GetBoolProperty("external_storage.casefold.enabled", false);
Captain Throwback88338682022-05-21 10:44:13 -04002464 needs_projid = android::base::GetBoolProperty("external_storage.projid.enabled", false);
bigbiff7ba75002020-04-11 20:47:09 -04002465 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2466 if (!dev_sz)
2467 return false;
2468
2469 if (NeedPreserveFooter)
2470 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
bigbiff7ba75002020-04-11 20:47:09 -04002471 char dev_sz_str[48];
2472 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
systemaddb475c92021-08-12 20:33:20 +02002473 if(needs_projid)
2474 f2fs_command += " -O project_quota,extra_attr";
2475
2476 if(needs_casefold)
2477 f2fs_command += " -O casefold -C utf8";
2478
2479 f2fs_command += " " + Actual_Block_Device + " " + dev_sz_str;
2480
Captain Throwback88338682022-05-21 10:44:13 -04002481 if (TWFunc::Path_Exists("/system/bin/sload_f2fs")) {
2482 f2fs_command += " && sload_f2fs -t /data " + Actual_Block_Device;
bigbiff7ba75002020-04-11 20:47:09 -04002483 }
2484
2485 /**
2486 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2487 * so there's no need to preserve footer.
2488 */
2489 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2490 Crypto_Key_Location != "footer") {
2491 NeedPreserveFooter = false;
2492 }
systemaddb475c92021-08-12 20:33:20 +02002493 LOGINFO("mkfs.f2fs command: %s\n", f2fs_command.c_str());
2494 if (TWFunc::Exec_Cmd(f2fs_command) == 0) {
bigbiff7ba75002020-04-11 20:47:09 -04002495 if (NeedPreserveFooter)
2496 Wipe_Crypto_Key();
2497 Recreate_AndSec_Folder();
2498 gui_msg("done=Done.");
2499 return true;
2500 } else {
2501 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2502 return false;
2503 }
2504 return true;
Dees_Troye5017042013-08-29 16:38:55 +00002505}
2506
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002507bool TWPartition::Wipe_NTFS() {
2508 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002509 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002510
bigbiff7ba75002020-04-11 20:47:09 -04002511 if (!UnMount(true))
2512 return false;
2513
bigbiffad58e1b2020-07-06 20:24:34 -04002514 if (TWFunc::Path_Exists("/system/bin/mkntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002515 Ntfsmake_Binary = "mkntfs";
bigbiffad58e1b2020-07-06 20:24:34 -04002516 else if (TWFunc::Path_Exists("/system/bin/mkfs.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002517 Ntfsmake_Binary = "mkfs.ntfs";
2518 else
2519 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002520
Greg Wallace4b44fef2015-12-29 15:33:24 -05002521 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002522 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002523 command = "/system/bin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002524 if (TWFunc::Exec_Cmd(command) == 0) {
2525 Recreate_AndSec_Folder();
2526 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002527 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002528 } else {
2529 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2530 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002531 }
2532 return false;
2533}
2534
Dees_Troy51a0e822012-09-05 15:24:24 -04002535bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002536#ifdef TW_OEM_BUILD
2537 // In an OEM Build we want to do a full format
2538 return Wipe_Encryption();
2539#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002540 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002541
Dees_Troy38bd7602012-09-14 13:33:53 -04002542 if (!Mount(true))
2543 return false;
2544
Ethan Yonker74db1572015-10-28 12:44:49 -05002545 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002546 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2547 if (ret)
2548 gui_msg("done=Done.");
2549 return ret;
2550#endif // ifdef TW_OEM_BUILD
2551}
2552
2553bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2554 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002555
2556 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002557 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002558 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002559 struct dirent* de;
2560 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002561 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002562
Ethan Yonker66a19492015-12-10 10:19:45 -06002563 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002564 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002565 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002566 LOGINFO("skipped '%s'\n", dir.c_str());
2567 continue;
2568 }
Dees_Troyce675462013-01-09 19:48:21 +00002569 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002570 dir.append("/");
2571 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2572 closedir(d);
2573 return false;
2574 }
2575 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002576 } 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 +03002577 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002578 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002579 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002580 }
2581 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002582
Dees_Troy16b74352012-11-14 22:27:31 +00002583 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002584 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002585 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002586 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002587}
2588
dianlujitao4879b372018-12-03 18:45:47 +08002589void TWPartition::Wipe_Crypto_Key() {
2590 Find_Actual_Block_Device();
2591 if (Crypto_Key_Location.empty())
2592 return;
2593 else if (Crypto_Key_Location == "footer") {
2594 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2595 if (fd < 0) {
2596 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2597 return;
2598 }
2599
2600 unsigned int block_count;
2601 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2602 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2603 } else {
2604 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2605 off64_t offset = ((off64_t)block_count * 512) - newlen;
2606 if (lseek64(fd, offset, SEEK_SET) == -1) {
2607 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2608 } else {
2609 void* buffer = malloc(newlen);
2610 if (!buffer) {
2611 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2612 } else {
2613 memset(buffer, 0, newlen);
2614 int ret = write(fd, buffer, newlen);
2615 if (ret != newlen) {
2616 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2617 } else {
2618 LOGINFO("Successfully wiped crypto footer.\n");
2619 }
2620 free(buffer);
2621 }
2622 }
2623 }
2624 close(fd);
2625 } else {
2626 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2627 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2628 TWFunc::Exec_Cmd(Command);
2629 } else {
2630 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2631 }
2632 }
2633}
2634
bigbiffce8f83c2015-12-12 18:30:21 -05002635bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002636 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002637 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002638
Dees_Troy43d8b002012-09-17 16:00:01 -04002639 if (!Mount(true))
2640 return false;
2641
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002642 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002643 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002644
Ethan Yonker472f5062016-02-25 13:47:30 -06002645 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002646
Dees_Troy83bd4832013-05-04 12:39:56 +00002647#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002648 if (Can_Encrypt_Backup) {
2649 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2650 if (tar.use_encryption) {
2651 if (Use_Userdata_Encryption)
2652 tar.userdata_encryption = tar.use_encryption;
2653 string Password;
2654 DataManager::GetValue("tw_backup_password", Password);
2655 tar.setpassword(Password);
2656 } else {
2657 tar.use_encryption = 0;
2658 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002659 }
2660#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002661
Ethan Yonker472f5062016-02-25 13:47:30 -06002662 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002663 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002664 if (Has_Data_Media)
2665 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 -04002666 if (Mount_Point == "/data" && DataManager::GetIntValue(TW_IS_FBE)) {
2667 std::vector<users_struct>::iterator iter;
2668 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
2669 for (iter = userList->begin(); iter != userList->end(); iter++) {
2670 if (!(*iter).isDecrypted && (*iter).userId != "0") {
2671 gui_msg(Msg(msg::kWarning,
2672 "backup_storage_undecrypt_warning=Backup will not include some files from user {1} "
2673 "because the user is not decrypted.")((*iter).userId));
2674 backup_exclusions.add_absolute_dir("/data/system_ce/" + (*iter).userId);
2675 backup_exclusions.add_absolute_dir("/data/misc_ce/" + (*iter).userId);
2676 backup_exclusions.add_absolute_dir("/data/vendor_ce/" + (*iter).userId);
2677 backup_exclusions.add_absolute_dir("/data/media/" + (*iter).userId);
2678 backup_exclusions.add_absolute_dir("/data/user/" + (*iter).userId);
2679 }
2680 }
2681 }
bigbiffce8f83c2015-12-12 18:30:21 -05002682 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002683 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002684 tar.setdir(Backup_Path);
2685 tar.setfn(Full_FileName);
2686 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002687 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002688 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002689 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002690 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002691 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002692}
2693
bigbiffce8f83c2015-12-12 18:30:21 -05002694bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2695 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002696
Ethan Yonker74db1572015-10-28 12:44:49 -05002697 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2698 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002699
Ethan Yonker472f5062016-02-25 13:47:30 -06002700 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002701
bigbiffce8f83c2015-12-12 18:30:21 -05002702 if (part_settings->adbbackup) {
2703 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002704 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002705 }
2706 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002707 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002708
2709 part_settings->total_restore_size = Backup_Size;
2710
2711 if (part_settings->adbbackup) {
2712 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2713 return false;
2714 }
2715
2716 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002717 return false;
2718
bigbiffce8f83c2015-12-12 18:30:21 -05002719 if (part_settings->adbbackup) {
2720 if (!twadbbu::Write_TWEOF())
2721 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002722 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002723 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002724}
2725
bigbiffce8f83c2015-12-12 18:30:21 -05002726bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2727 unsigned long long RW_Block_Size, Remain = Backup_Size;
2728 int src_fd = -1, dest_fd = -1;
2729 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002730 bool ret = false;
2731 void* buffer = NULL;
2732 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002733 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002734
bigbiffce8f83c2015-12-12 18:30:21 -05002735 if (part_settings->PM_Method == PM_BACKUP) {
2736 srcfn = Actual_Block_Device;
2737 if (part_settings->adbbackup)
2738 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002739 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002740 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002741 }
bigbiffce8f83c2015-12-12 18:30:21 -05002742 }
2743 else {
2744 destfn = Actual_Block_Device;
2745 if (part_settings->adbbackup) {
2746 srcfn = TW_ADB_RESTORE;
2747 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002748 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002749 Remain = TWFunc::Get_File_Size(srcfn);
2750 }
2751 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002752
bigbiffce8f83c2015-12-12 18:30:21 -05002753 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002754 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002755 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002756 return false;
2757 }
bigbiffce8f83c2015-12-12 18:30:21 -05002758
2759 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 -06002760 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002761 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002762 goto exit;
2763 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002764
bigbiffce8f83c2015-12-12 18:30:21 -05002765 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2766
2767 if (part_settings->adbbackup) {
2768 RW_Block_Size = MAX_ADB_READ;
2769 bs = MAX_ADB_READ;
2770 }
2771 else {
2772 RW_Block_Size = 1048576LLU; // 1MB
2773 bs = (ssize_t)(RW_Block_Size);
2774 }
2775
Ethan Yonker472f5062016-02-25 13:47:30 -06002776 buffer = malloc((size_t)bs);
2777 if (!buffer) {
2778 LOGINFO("Raw_Read_Write failed to malloc\n");
2779 goto exit;
2780 }
bigbiffce8f83c2015-12-12 18:30:21 -05002781
2782 if (part_settings->progress)
2783 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2784
Ethan Yonker472f5062016-02-25 13:47:30 -06002785 while (Remain > 0) {
2786 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002787 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002788 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002789 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2790 goto exit;
2791 }
2792 if (write(dest_fd, buffer, bs) != bs) {
2793 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2794 goto exit;
2795 }
2796 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002797 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002798 if (part_settings->progress)
2799 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002800 if (PartitionManager.Check_Backup_Cancel() != 0)
2801 goto exit;
2802 }
bigbiffce8f83c2015-12-12 18:30:21 -05002803 if (part_settings->progress)
2804 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002805 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002806
2807 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2808 tw_set_default_metadata(destfn.c_str());
2809 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2810 }
2811
Ethan Yonker472f5062016-02-25 13:47:30 -06002812 ret = true;
2813exit:
2814 if (src_fd >= 0)
2815 close(src_fd);
2816 if (dest_fd >= 0)
2817 close(dest_fd);
2818 if (buffer)
2819 free(buffer);
2820 return ret;
2821}
2822
bigbiffce8f83c2015-12-12 18:30:21 -05002823bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002824 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002825
Ethan Yonker74db1572015-10-28 12:44:49 -05002826 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2827 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002828
bigbiffce8f83c2015-12-12 18:30:21 -05002829 if (part_settings->progress)
2830 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002831
Ethan Yonker472f5062016-02-25 13:47:30 -06002832 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002833 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002834
2835 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002836
Dees_Troy2673cec2013-04-02 20:22:16 +00002837 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002838 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002839 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002840 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2841 // 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 -06002842 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002843 return false;
2844 }
bigbiffce8f83c2015-12-12 18:30:21 -05002845 if (part_settings->progress)
2846 part_settings->progress->UpdateSize(Backup_Size);
2847
Dees_Troy43d8b002012-09-17 16:00:01 -04002848 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002849}
2850
bigbiffce8f83c2015-12-12 18:30:21 -05002851unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2852 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002853 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002854 if (restore_info.LoadValues() == 0) {
2855 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2856 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2857 return Restore_Size;
2858 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002859 }
2860 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002861
Matt Mower029a82d2017-01-08 13:12:38 -06002862 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2863 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002864
2865 if (Is_Image(Restore_File_System)) {
2866 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2867 return Restore_Size;
2868 }
2869
2870 twrpTar tar;
2871 tar.setdir(Backup_Path);
2872 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002873 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002874#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2875 string Password;
2876 DataManager::GetValue("tw_restore_password", Password);
2877 if (!Password.empty())
2878 tar.setpassword(Password);
2879#endif
2880 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002881 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002882 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002883 Restore_Size = tar.get_size();
2884 return Restore_Size;
2885}
2886
bigbiffce8f83c2015-12-12 18:30:21 -05002887bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002888 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002889 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002890 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002891
Dees_Troye58d5262012-09-21 12:27:57 -04002892 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002893 if (!Wipe_AndSec())
2894 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002895 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002896 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002897 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002898 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 -05002899 if (!Wipe_Data_Without_Wiping_Media())
2900 return false;
2901 } else {
2902 if (!Wipe(Restore_File_System))
2903 return false;
2904 }
Dees_Troye58d5262012-09-21 12:27:57 -04002905 }
Matt Mower3c366972015-12-25 19:28:31 -06002906 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002907 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002908
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002909 // Remount as read/write as needed so we can restore the backup
2910 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002911 return false;
2912
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002913 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002914 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002915 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002916 tar.setdir(Backup_Path);
2917 tar.setfn(Full_FileName);
2918 tar.backup_name = Backup_Name;
2919#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2920 string Password;
2921 DataManager::GetValue("tw_restore_password", Password);
2922 if (!Password.empty())
2923 tar.setpassword(Password);
2924#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002925 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2926 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002927 ret = false;
2928 else
2929 ret = true;
2930#ifdef HAVE_CAPABILITIES
2931 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002932 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002933 struct vfs_cap_data cap_data;
2934 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2935
2936 memset(&cap_data, 0, sizeof(cap_data));
2937 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2938 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2939 cap_data.data[0].inheritable = 0;
2940 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2941 cap_data.data[1].inheritable = 0;
2942 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2943 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2944 } else {
2945 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2946 }
2947 }
2948#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002949 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2950 // Remount as read only when restoration is complete
2951 ReMount(true);
2952
Dees Troy4159aed2014-02-28 17:24:43 +00002953 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002954}
2955
bigbiffce8f83c2015-12-12 18:30:21 -05002956bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002957 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002958 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002959
Matt Mower3c366972015-12-25 19:28:31 -06002960 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002961 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002962
2963 if (part_settings->adbbackup)
2964 Full_FileName = TW_ADB_RESTORE;
2965 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002966 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002967
Ethan Yonker96af84a2015-01-05 14:58:36 -06002968 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002969 if (!part_settings->adbbackup)
2970 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2971 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002972 return false;
2973 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002974 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2975 return false;
2976 }
2977
2978 if (part_settings->adbbackup) {
2979 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002980 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002981 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002982 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002983}
Dees_Troy5bf43922012-09-07 16:07:55 -04002984
2985bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002986 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002987
Ethan Yonker1b190162016-12-05 15:25:19 -06002988 Find_Actual_Block_Device();
2989
bigbiffee7b7ff2020-03-23 15:08:27 -04002990 if (Actual_Block_Device.empty())
2991 return false;
2992
Ethan Yonker1b190162016-12-05 15:25:19 -06002993 if (!Can_Be_Mounted && !Is_Encrypted) {
2994 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2995 Used = Size;
2996 Backup_Size = Size;
2997 return true;
2998 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002999 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06003000 }
Dees_Troy5bf43922012-09-07 16:07:55 -04003001
Dees_Troy0550cfb2012-10-13 11:56:13 -04003002 Was_Already_Mounted = Is_Mounted();
bigbiffee7b7ff2020-03-23 15:08:27 -04003003
Dees_Troy38bd7602012-09-14 13:33:53 -04003004 if (Removable || Is_Encrypted) {
3005 if (!Mount(false))
3006 return true;
3007 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04003008 return false;
Dees_Troy51127312012-09-08 13:08:49 -04003009
3010 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003011 if (!ret || Size == 0) {
3012 if (!Get_Size_Via_df(Display_Error)) {
3013 if (!Was_Already_Mounted)
3014 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04003015 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003016 }
3017 }
Dees_Troy51127312012-09-08 13:08:49 -04003018
Dees_Troy5bf43922012-09-07 16:07:55 -04003019 if (Has_Data_Media) {
3020 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003021 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003022 Backup_Size = Used;
3023 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04003024 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003025 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003026 } else {
3027 if (!Was_Already_Mounted)
3028 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04003029 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003030 }
Dees_Troye58d5262012-09-21 12:27:57 -04003031 } else if (Has_Android_Secure) {
3032 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003033 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003034 else {
3035 if (!Was_Already_Mounted)
3036 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04003037 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003038 }
Dees_Troy5bf43922012-09-07 16:07:55 -04003039 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04003040 if (!Was_Already_Mounted)
3041 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04003042 return true;
Dees_Troy51127312012-09-08 13:08:49 -04003043}
Dees_Troy38bd7602012-09-14 13:33:53 -04003044
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003045bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
3046 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
3047 string Path = TWFunc::Get_Path(Device);
3048 string Dev = TWFunc::Get_Filename(Device);
3049 size_t wildcard_index = Dev.find("*");
3050 if (wildcard_index != string::npos)
3051 Dev = Dev.substr(0, wildcard_index);
3052 wildcard_index = Dev.size();
3053 DIR* d = opendir(Path.c_str());
3054 if (d == NULL) {
3055 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
3056 return false;
3057 }
3058 struct dirent* de;
3059 while ((de = readdir(d)) != NULL) {
3060 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
3061 continue;
3062
3063 string item = Path + "/";
3064 item.append(de->d_name);
3065 if (PartitionManager.Find_Partition_By_Block_Device(item))
3066 continue;
3067 TWPartition *part = new TWPartition;
3068 char buffer[MAX_FSTAB_LINE_LENGTH];
3069 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
bigbiff8da46fa2020-09-08 16:42:34 -04003070 part->Process_Fstab_Line(buffer, false, NULL);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003071 char display[MAX_FSTAB_LINE_LENGTH];
3072 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
3073 part->Storage_Name = display;
3074 part->Display_Name = display;
3075 part->Primary_Block_Device = item;
3076 part->Wildcard_Block_Device = false;
3077 part->Is_SubPartition = true;
3078 part->SubPartition_Of = Mount_Point;
3079 part->Is_Storage = Is_Storage;
3080 part->Can_Be_Mounted = true;
3081 part->Removable = true;
3082 part->Can_Be_Wiped = Can_Be_Wiped;
3083 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
3084 part->Find_Actual_Block_Device();
3085 part->Update_Size(false);
3086 Has_SubPartition = true;
3087 PartitionManager.Output_Partition(part);
3088 PartitionManager.Add_Partition(part);
3089 }
3090 closedir(d);
3091 return (mount_point_index > 0);
3092}
3093
Dees_Troy38bd7602012-09-14 13:33:53 -04003094void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003095 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
3096 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
3097 * If we have a syfs entry then we are looking for this device from a uevent add.
3098 * The uevent add will set the primary block device based on the data we receive from
3099 * after checking for adopted storage. If the device ends up being adopted, then the
3100 * decrypted block device will be set instead of the primary block device. */
3101 Is_Present = false;
3102 return;
3103 }
3104 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
3105 Is_Present = false;
3106 Actual_Block_Device = "";
3107 Can_Be_Mounted = false;
3108 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
3109 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
3110 if (TWFunc::Path_Exists(Dev)) {
3111 Is_Present = true;
3112 Can_Be_Mounted = true;
3113 Actual_Block_Device = Dev;
3114 }
3115 }
3116 return;
3117 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003118 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06003119 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003120 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06003121 return;
3122 }
3123 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
3124 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
3125 unlink(Primary_Block_Device.c_str());
3126 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
3127 Is_Present = true;
3128 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04003129 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003130 Is_Present = true;
3131 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003132 return;
3133 }
Ethan Yonker1b190162016-12-05 15:25:19 -06003134 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04003135 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04003136 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003137 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04003138 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003139 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003140}
3141
3142void TWPartition::Recreate_Media_Folder(void) {
3143 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06003144 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04003145
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06003146 if (Is_FBE) {
3147 LOGINFO("Not recreating media folder on FBE\n");
3148 return;
3149 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003150 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003151 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
3152 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003153 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06003154 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
3155 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08003156 string Internal_path = DataManager::GetStrValue("tw_internal_path");
3157 if (!Internal_path.empty()) {
3158 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
3159 mkdir(Internal_path.c_str(), 0770);
3160 }
3161#ifdef TW_INTERNAL_STORAGE_PATH
3162 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
3163#endif
Matt Mower87413642017-01-17 21:14:46 -06003164
thata3d31fb2014-12-21 22:27:40 +01003165 // Afterwards, we will try to set the
3166 // default metadata that we were hopefully able to get during
3167 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06003168 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08003169 if (!Internal_path.empty())
3170 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06003171
Ethan Yonker5eac2222014-06-11 12:22:55 -05003172 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003173 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003174 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003175 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003176}
Dees_Troye58d5262012-09-21 12:27:57 -04003177
3178void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003179 if (!Has_Android_Secure)
3180 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003181 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003182 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003183 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003184 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003185 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003186 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003187 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003188 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003189 }
3190}
bigbiff7cb4c332014-11-26 20:36:07 -05003191
3192uint64_t TWPartition::Get_Max_FileSize() {
3193 uint64_t maxFileSize = 0;
3194 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3195 const uint64_t constTB = (uint64_t) constGB * 1024;
3196 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003197 if (Current_File_System == "ext4")
3198 maxFileSize = 16 * constTB; //16 TB
3199 else if (Current_File_System == "vfat")
3200 maxFileSize = 4 * constGB; //4 GB
Captain Throwback47bf7202020-10-06 17:39:39 -04003201 else if (Current_File_System == "ntfs" || Current_File_System == "tntfs")
bigbiff0c532032014-12-21 13:41:26 -05003202 maxFileSize = 256 * constTB; //256 TB
3203 else if (Current_File_System == "exfat")
3204 maxFileSize = 16 * constPB; //16 PB
3205 else if (Current_File_System == "ext3")
3206 maxFileSize = 2 * constTB; //2 TB
3207 else if (Current_File_System == "f2fs")
3208 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003209 else
3210 maxFileSize = 100000000L;
3211 return maxFileSize - 1;
3212}
3213
bigbiffce8f83c2015-12-12 18:30:21 -05003214bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3215 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003216
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003217 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003218
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003219 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003220
3221 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003222 LOGERR("Cannot flash images to file systems\n");
3223 return false;
3224 } else if (!Can_Flash_Img) {
3225 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3226 return false;
3227 } else {
3228 if (!Find_Partition_Size()) {
3229 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3230 return false;
3231 }
bigbiffce8f83c2015-12-12 18:30:21 -05003232 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003233 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003234 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003235 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003236 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003237 return false;
3238 }
bigbiffce8f83c2015-12-12 18:30:21 -05003239 if (Backup_Method == BM_DD) {
3240 if (!part_settings->adbbackup) {
3241 if (Is_Sparse_Image(full_filename)) {
3242 return Flash_Sparse_Image(full_filename);
3243 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003244 }
bigbiffce8f83c2015-12-12 18:30:21 -05003245 return Raw_Read_Write(part_settings);
3246 } else if (Backup_Method == BM_FLASH_UTILS) {
3247 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003248 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003249 }
3250
3251 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3252 return false;
3253}
3254
Ethan Yonker472f5062016-02-25 13:47:30 -06003255bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003256 uint32_t magic = 0;
3257 int fd = open(Filename.c_str(), O_RDONLY);
3258 if (fd < 0) {
3259 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3260 return false;
3261 }
bigbiffce8f83c2015-12-12 18:30:21 -05003262
HashBanged974bb2016-01-30 14:20:09 -05003263 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3264 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3265 close(fd);
3266 return false;
3267 }
3268 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003269 if (magic == SPARSE_HEADER_MAGIC)
3270 return true;
3271 return false;
3272}
3273
3274bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3275 string Command;
3276
3277 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3278
3279 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003280 LOGINFO("Flash command: '%s'\n", Command.c_str());
3281 TWFunc::Exec_Cmd(Command);
3282 return true;
3283}
3284
Ethan Yonker472f5062016-02-25 13:47:30 -06003285bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003286 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003287 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003288
Ethan Yonker74db1572015-10-28 12:44:49 -05003289 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003290 if (progress) {
3291 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3292 progress->SetPartitionSize(file_size);
3293 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003294 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3295 Command = "erase_image " + MTD_Name;
3296 LOGINFO("Erase command: '%s'\n", Command.c_str());
3297 TWFunc::Exec_Cmd(Command);
3298 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3299 LOGINFO("Flash command: '%s'\n", Command.c_str());
3300 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003301 if (progress)
3302 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003303 return true;
3304}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003305
3306void TWPartition::Change_Mount_Read_Only(bool new_value) {
3307 Mount_Read_Only = new_value;
3308}
3309
bigbiffce8f83c2015-12-12 18:30:21 -05003310bool TWPartition::Is_Read_Only() {
3311 return Mount_Read_Only;
3312}
3313
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003314int TWPartition::Check_Lifetime_Writes() {
3315 bool original_read_only = Mount_Read_Only;
3316 int ret = 1;
3317
3318 Mount_Read_Only = true;
3319 if (Mount(false)) {
3320 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003321 string temp = Actual_Block_Device;
3322 Find_Real_Block_Device(temp, false);
3323 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003324 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3325 string result;
3326 if (TWFunc::Path_Exists(file)) {
3327 if (TWFunc::read_file(file, result) != 0) {
3328 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3329 } else {
3330 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3331 if (result == "0") {
3332 ret = 0;
3333 }
3334 }
3335 } else {
3336 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3337 }
3338 UnMount(true);
3339 } else {
3340 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3341 }
3342 Mount_Read_Only = original_read_only;
3343 return ret;
3344}
Ethan Yonker66a19492015-12-10 10:19:45 -06003345
3346int TWPartition::Decrypt_Adopted() {
3347#ifdef TW_INCLUDE_CRYPTO
3348 int ret = 1;
3349 Is_Adopted_Storage = false;
3350 string Adopted_Key_File = "";
3351
3352 if (!Removable)
3353 return ret;
3354
3355 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3356 if (fd < 0) {
3357 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3358 return ret;
3359 }
3360 char type_guid[80];
3361 char part_guid[80];
3362
nkk717aa6fc62017-03-24 18:28:03 +02003363 uint32_t p_num;
3364 size_t last_digit = Primary_Block_Device.find_last_not_of("0123456789");
3365 if ((last_digit != string::npos) && (last_digit != Primary_Block_Device.length()-1))
3366 p_num = atoi(Primary_Block_Device.substr(last_digit + 1).c_str()) + 1;
3367 else
3368 p_num = 2;
3369
3370 if (gpt_disk_get_partition_info(fd, p_num, type_guid, part_guid) == 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003371 LOGINFO("type: '%s'\n", type_guid);
3372 LOGINFO("part: '%s'\n", part_guid);
3373 Adopted_GUID = part_guid;
3374 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3375 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3376 LOGINFO("android_expand found\n");
3377 Adopted_Key_File = "/data/misc/vold/expand_";
3378 Adopted_Key_File += part_guid;
3379 Adopted_Key_File += ".key";
3380 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3381 Is_Adopted_Storage = true;
3382 /* Until we find a use case for this, I think it is safe
3383 * to disable USB Mass Storage whenever adopted storage
3384 * is present.
3385 */
nkk717aa6fc62017-03-24 18:28:03 +02003386 if (p_num == 2) {
3387 // TODO: Properly detect mixed vs fully adopted storage. Maybe this
3388 // should be moved to partitionmanager instead, and disable after
3389 // checking all partitions. Also the presence of adopted storage does
3390 // not necessarily mean it's being used as Internal Storage
3391 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3392 DataManager::SetValue("tw_has_usb_storage", 0);
3393 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003394 }
3395 }
3396 }
3397
3398 if (Is_Adopted_Storage) {
nkk717aa6fc62017-03-24 18:28:03 +02003399 string Adopted_Block_Device = Alternate_Block_Device + "p" + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003400 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
nkk717aa6fc62017-03-24 18:28:03 +02003401 Adopted_Block_Device = Alternate_Block_Device + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003402 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3403 LOGINFO("Adopted block device does not exist\n");
3404 goto exit;
3405 }
3406 }
3407 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3408 char crypto_blkdev[MAXPATHLEN];
3409 std::string thekey;
3410 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3411 if (fdkey < 0) {
3412 LOGINFO("failed to open key file\n");
3413 goto exit;
3414 }
3415 char buf[512];
3416 ssize_t n;
3417 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3418 thekey.append(buf, n);
3419 }
3420 close(fdkey);
bigbiffdf53b6c2022-01-17 19:31:52 -05003421 // unsigned char* key = (unsigned char*) thekey.data();
3422 // cryptfs_revert_ext_volume(part_guid);
Ethan Yonker66a19492015-12-10 10:19:45 -06003423
bigbiffdf53b6c2022-01-17 19:31:52 -05003424 // ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
Ethan Yonker66a19492015-12-10 10:19:45 -06003425 if (ret == 0) {
3426 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3427 Decrypted_Block_Device = crypto_blkdev;
3428 Is_Decrypted = true;
3429 Is_Encrypted = true;
3430 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003431 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003432 LOGERR("Failed to mount decrypted adopted storage device\n");
3433 Is_Decrypted = false;
3434 Is_Encrypted = false;
bigbiffdf53b6c2022-01-17 19:31:52 -05003435 // cryptfs_revert_ext_volume(part_guid);
Ethan Yonker66a19492015-12-10 10:19:45 -06003436 ret = 1;
3437 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003438 UnMount(false);
3439 Has_Android_Secure = false;
3440 Symlink_Path = "";
3441 Symlink_Mount_Point = "";
3442 Backup_Name = Mount_Point.substr(1);
3443 Backup_Path = Mount_Point;
3444 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3445 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3446 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3447 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3448 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003449 Setup_Data_Media();
Ethan Yonker66a19492015-12-10 10:19:45 -06003450 Wipe_Available_in_GUI = true;
3451 Wipe_During_Factory_Reset = true;
3452 Can_Be_Backed_Up = true;
3453 Can_Encrypt_Backup = true;
3454 Use_Userdata_Encryption = true;
3455 Is_Storage = true;
3456 Storage_Name = "Adopted Storage";
3457 Is_SubPartition = true;
3458 SubPartition_Of = "/data";
3459 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3460 DataManager::SetValue("tw_has_adopted_storage", 1);
3461 }
3462 } else {
3463 LOGERR("Failed to setup adopted storage decryption\n");
3464 }
3465 }
3466exit:
Matt Mower06543e32017-01-06 15:25:26 -06003467 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003468 return ret;
3469#else
3470 LOGINFO("Decrypt_Adopted: no crypto support\n");
3471 return 1;
3472#endif
3473}
3474
3475void TWPartition::Revert_Adopted() {
3476#ifdef TW_INCLUDE_CRYPTO
3477 if (!Adopted_GUID.empty()) {
3478 PartitionManager.Remove_MTP_Storage(Mount_Point);
3479 UnMount(false);
bigbiffdf53b6c2022-01-17 19:31:52 -05003480 // cryptfs_revert_ext_volume(Adopted_GUID.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06003481 Is_Adopted_Storage = false;
3482 Is_Encrypted = false;
3483 Is_Decrypted = false;
3484 Decrypted_Block_Device = "";
3485 Find_Actual_Block_Device();
3486 Wipe_During_Factory_Reset = false;
3487 Can_Be_Backed_Up = false;
3488 Can_Encrypt_Backup = false;
3489 Use_Userdata_Encryption = false;
3490 Is_SubPartition = false;
3491 SubPartition_Of = "";
3492 Has_Data_Media = false;
3493 Storage_Path = Mount_Point;
3494 if (!Symlink_Mount_Point.empty()) {
3495 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3496 if (Dat) {
3497 Dat->UnMount(false);
3498 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3499 }
3500 Symlink_Mount_Point = "";
3501 }
3502 }
3503#else
3504 LOGINFO("Revert_Adopted: no crypto support\n");
3505#endif
3506}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003507
3508void TWPartition::Set_Backup_FileName(string fname) {
3509 Backup_FileName = fname;
3510}
3511
3512string TWPartition::Get_Backup_Name() {
3513 return Backup_Name;
3514}
bigbiffee7b7ff2020-03-23 15:08:27 -04003515
3516string TWPartition::Get_Mount_Point() {
3517 return Mount_Point;
3518}
3519
3520void TWPartition::Set_Block_Device(std::string block_device) {
3521 Primary_Block_Device = Actual_Block_Device = block_device;
3522}
3523
3524bool TWPartition::Get_Super_Status() {
3525 return Is_Super;
3526}
3527
3528void TWPartition::Set_Can_Be_Backed_Up(bool val) {
3529 Can_Be_Backed_Up = val;
3530}
3531
3532void TWPartition::Set_Can_Be_Wiped(bool val) {
3533 Can_Be_Wiped = val;
3534 Wipe_Available_in_GUI = val;
bigbiffad58e1b2020-07-06 20:24:34 -04003535}
3536
3537std::string TWPartition::Get_Backup_FileName() {
3538 return Backup_FileName;
3539}
3540
3541std::string TWPartition::Get_Display_Name() {
3542 return Display_Name;
3543}
3544
3545bool TWPartition::Is_SlotSelect() {
3546 return SlotSelect;
Mohd Faraz815e2402020-09-19 19:31:52 +05303547}