blob: 18528f11706b244b022fb23fe4f4d15e1ff1f079 [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,
Darth99fb13af2023-04-07 23:32:45 +0100169 TWFLAG_FS_COMPRESS,
bigbiff998f8392021-08-06 19:19:33 -0400170 TWFLAG_LOGICAL,
Matt Mower2416a502016-04-12 19:54:46 -0500171};
172
173/* Flags without a trailing '=' are considered dual format flags and can be
174 * written as either 'flagname' or 'flagname=', where the character following
175 * the '=' is Y,y,1 for true and false otherwise.
176 */
177const struct flag_list tw_flags[] = {
178 { "andsec", TWFLAG_ANDSEC },
179 { "backup", TWFLAG_BACKUP },
180 { "backupname=", TWFLAG_BACKUPNAME },
181 { "blocksize=", TWFLAG_BLOCKSIZE },
182 { "canbewiped", TWFLAG_CANBEWIPED },
183 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
184 { "defaults", TWFLAG_DEFAULTS },
185 { "display=", TWFLAG_DISPLAY },
186 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500187 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Captain Throwbackf74fe4f2022-02-08 12:45:01 -0500188 { "metadata_encryption=", TWFLAG_METADATA_ENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500189 { "flashimg", TWFLAG_FLASHIMG },
190 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
191 { "fsflags=", TWFLAG_FSFLAGS },
192 { "ignoreblkid", TWFLAG_IGNOREBLKID },
193 { "length=", TWFLAG_LENGTH },
194 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
Captain Throwback8d97d422022-02-08 15:31:44 -0500195 { "quota", TWFLAG_QUOTA },
Matt Mower2416a502016-04-12 19:54:46 -0500196 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500197 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
198 { "storage", TWFLAG_STORAGE },
199 { "storagename=", TWFLAG_STORAGENAME },
200 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
201 { "symlink=", TWFLAG_SYMLINK },
202 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
203 { "usermrf", TWFLAG_USERMRF },
204 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
205 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600206 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600207 { "wait", TWFLAG_WAIT },
208 { "verify", TWFLAG_VERIFY },
209 { "check", TWFLAG_CHECK },
210 { "altdevice", TWFLAG_ALTDEVICE },
211 { "notrim", TWFLAG_NOTRIM },
212 { "voldmanaged=", TWFLAG_VOLDMANAGED },
213 { "formattable", TWFLAG_FORMATTABLE },
214 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500215 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800216 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800217 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800218 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
Darth99fb13af2023-04-07 23:32:45 +0100219 { "fscompress", TWFLAG_FS_COMPRESS },
bigbiff998f8392021-08-06 19:19:33 -0400220 { "logical", TWFLAG_LOGICAL },
Matt Mower2416a502016-04-12 19:54:46 -0500221 { 0, 0 },
222};
223
that9e0593e2014-10-08 00:01:24 +0200224TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400225 Can_Be_Mounted = false;
226 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500227 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200228 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400229 Wipe_During_Factory_Reset = false;
230 Wipe_Available_in_GUI = false;
231 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400232 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400233 SubPartition_Of = "";
234 Symlink_Path = "";
235 Symlink_Mount_Point = "";
236 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400237 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600238 Wildcard_Block_Device = false;
239 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400240 Actual_Block_Device = "";
241 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400242 Alternate_Block_Device = "";
243 Removable = false;
244 Is_Present = false;
245 Length = 0;
246 Size = 0;
247 Used = 0;
248 Free = 0;
249 Backup_Size = 0;
250 Can_Be_Encrypted = false;
251 Is_Encrypted = false;
252 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600253 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600254 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400255 Decrypted_Block_Device = "";
256 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500257 Backup_Display_Name = "";
258 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400259 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400260 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400261 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500262 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000263 Can_Encrypt_Backup = false;
264 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400265 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400266 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400267 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500268 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400269 Storage_Path = "";
270 Current_File_System = "";
271 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800272 Mount_Flags = 0;
273 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400274 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000275 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800276 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600277 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600278 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500279 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600280 Is_Adopted_Storage = false;
281 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600282 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500283 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400284 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800285 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800286 Original_Path = "";
287 Use_Original_Path = false;
Darth99fb13af2023-04-07 23:32:45 +0100288 Needs_Fs_Compress = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400289}
290
291TWPartition::~TWPartition(void) {
292 // Do nothing
293}
294
bigbiff8da46fa2020-09-08 16:42:34 -0400295bool 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 -0500296 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500297 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400298 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500299 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500300 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600301 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
302 TWPartition *additional_entry = NULL;
303 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400304
Matt Mower2b2dd152016-04-26 11:24:08 -0500305 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400306
Dees_Troy51127312012-09-08 13:08:49 -0400307 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500308 if (full_line[index] == 34)
309 skip = !skip;
310 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400311 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400312 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600313 if (line_len < 10)
314 return false; // There can't possibly be a valid fstab line that is less than 10 chars
bigbiff998f8392021-08-06 19:19:33 -0400315 if (fstab_line[0] == '#')
316 return false; // skip comments
317
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600318 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
319 fstab_version = 2;
320 block_device_index = 0;
321 mount_point_index = 1;
322 fs_index = 2;
323 }
324
bigbiff998f8392021-08-06 19:19:33 -0400325 if (fstab_line[0] != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400326 block_device_index = 0;
327 fstab_version = 2;
328 mount_point_index = 1;
329 fs_index = 2;
330 }
331
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600332 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400333 while (index < line_len) {
334 while (index < line_len && full_line[index] == '\0')
335 index++;
336 if (index >= line_len)
337 continue;
338 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600339 if (item_index == mount_point_index) {
340 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400341 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600342 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400343 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600344 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
345 }
346 }
bigbiff8da46fa2020-09-08 16:42:34 -0400347 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600348 Backup_Path = Mount_Point;
349 Storage_Path = Mount_Point;
350 Display_Name = ptr + 1;
351 Backup_Display_Name = Display_Name;
352 Storage_Name = Display_Name;
353 item_index++;
354 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400355 // File System
356 Fstab_File_System = ptr;
357 Current_File_System = ptr;
358 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600359 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400360 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400361 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400362 MTD_Name = ptr;
363 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400364 } else if (Fstab_File_System == "bml") {
365 if (Mount_Point == "/boot")
366 MTD_Name = "boot";
367 else if (Mount_Point == "/recovery")
368 MTD_Name = "recovery";
369 Primary_Block_Device = ptr;
370 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000371 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 -0400372 } else {
373 Primary_Block_Device = ptr;
bigbiff998f8392021-08-06 19:19:33 -0400374 if (*ptr == '/')
375 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400376 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400377 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600378 } else if (item_index > 2) {
379 if (fstab_version == 2) {
380 if (item_index == 3) {
381 Process_FS_Flags(ptr);
382 if (additional_entry) {
383 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
384 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
385 }
386 } else {
387 strlcpy(twflags, ptr, sizeof(twflags));
388 }
389 item_index++;
390 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400391 // Alternate Block Device
392 Alternate_Block_Device = ptr;
393 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
394 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
395 // Partition length
396 ptr += 7;
397 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400398 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
399 // Custom flags, save for later so that new values aren't overwritten by defaults
400 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500401 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400402 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
403 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400404 } else {
405 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500406 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400407 }
408 }
409 while (index < line_len && full_line[index] != '\0')
410 index++;
411 }
412
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600413 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
414 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
415 it = twrp_flags->find(Mount_Point);
416 if (it != twrp_flags->end()) {
417 if (!it->second.Primary_Block_Device.empty()) {
418 Primary_Block_Device = it->second.Primary_Block_Device;
419 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
420 }
421 if (!it->second.Alternate_Block_Device.empty()) {
422 Alternate_Block_Device = it->second.Alternate_Block_Device;
423 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
424 }
425 }
426 }
427
428 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
429 Sysfs_Entry = Primary_Block_Device;
430 Primary_Block_Device = "";
431 Is_Storage = true;
432 Removable = true;
433 Wipe_Available_in_GUI = true;
434 Wildcard_Block_Device = true;
435 }
436 if (Primary_Block_Device.find("*") != string::npos)
437 Wildcard_Block_Device = true;
438
bigbiff8da46fa2020-09-08 16:42:34 -0400439 if (Mount_Point == "auto") {
440 Mount_Point = "/auto";
441 char autoi[5];
442 sprintf(autoi, "%i", auto_index);
443 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600444 Backup_Path = Mount_Point;
445 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800446 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600447 auto_index++;
448 Setup_File_System(Display_Error);
449 Display_Name = "Storage";
450 Backup_Display_Name = Display_Name;
451 Storage_Name = Display_Name;
452 Can_Be_Backed_Up = false;
453 Wipe_Available_in_GUI = true;
454 Is_Storage = true;
455 Removable = true;
456 Wipe_Available_in_GUI = true;
457 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400458 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000459 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400460 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000461 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500462 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400463 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400464 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400465 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800466 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100467 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400468 Mount_Point = PartitionManager.Get_Android_Root_Path();
469 Backup_Path = Mount_Point;
470 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400471 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800472 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500473 Backup_Display_Name = Display_Name;
474 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400475 Wipe_Available_in_GUI = false;
476 Can_Be_Backed_Up = false;
477 Can_Be_Wiped = false;
bigbiff8da46fa2020-09-08 16:42:34 -0400478 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
me-cafebabe701e9ab2022-07-29 06:34:45 +0800479 } else if (Mount_Point == "/system_ext") {
480 Display_Name = "System_EXT";
481 Backup_Name = "System_EXT";
482 Backup_Display_Name = Display_Name;
483 Storage_Name = Display_Name;
484 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Mohd Faraze3948ec2020-08-14 01:40:59 +0000485 } else if (Mount_Point == "/product") {
486 Display_Name = "Product";
487 Backup_Name = "Product";
488 Backup_Display_Name = Display_Name;
489 Storage_Name = Display_Name;
490 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Mohd Faraze3948ec2020-08-14 01:40:59 +0000491 } else if (Mount_Point == "/odm") {
492 Display_Name = "ODM";
493 Backup_Name = "ODM";
494 Backup_Display_Name = Display_Name;
495 Storage_Name = Display_Name;
496 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400497 } else if (Mount_Point == "/data") {
498 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500499 Backup_Display_Name = Display_Name;
500 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400501 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400502 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500503 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000504 Can_Encrypt_Backup = true;
505 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400506 } else if (Mount_Point == "/cache") {
507 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500508 Backup_Display_Name = Display_Name;
509 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400510 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400511 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500512 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400513 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400514 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400515 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500516 Backup_Display_Name = Display_Name;
517 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400518 Is_SubPartition = true;
519 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400520 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500521 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000522 Can_Encrypt_Backup = true;
523 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400524 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400525 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400526 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500527 Backup_Display_Name = Display_Name;
528 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400529 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400530 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500531 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000532 Can_Encrypt_Backup = true;
533 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400534 } else if (Mount_Point == "/boot") {
535 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500536 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400537 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500538 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500539 } else if (Mount_Point == "/vendor") {
540 Display_Name = "Vendor";
541 Backup_Display_Name = Display_Name;
542 Storage_Name = Display_Name;
me-cafebabe44e06ee2023-07-30 18:32:57 +0800543 } else if (Mount_Point == "/metadata") {
544 Display_Name = "Metadata";
545 Backup_Display_Name = Display_Name;
546 Storage_Name = Display_Name;
547 } else if (Mount_Point == "/odm_dlkm") {
548 Display_Name = "ODM DLKM";
549 Backup_Display_Name = Display_Name;
550 Storage_Name = Display_Name;
551 } else if (Mount_Point == "/vendor_dlkm") {
552 Display_Name = "Vendor DLKM";
553 Backup_Display_Name = Display_Name;
554 Storage_Name = Display_Name;
Dees_Troy8170a922012-09-18 15:40:25 -0400555 }
556#ifdef TW_EXTERNAL_STORAGE_PATH
557 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
558 Is_Storage = true;
559 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400560 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500561 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400562#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000563 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400564 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400565 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500566 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400567#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000568 }
Dees_Troy8170a922012-09-18 15:40:25 -0400569#ifdef TW_INTERNAL_STORAGE_PATH
570 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
571 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500572 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400573 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500574 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400575 }
576#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000577 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400578 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500579 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500580 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400581 }
582#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400583 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400584 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600585 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500586 if (Mount_Point == "/boot") {
587 Display_Name = "Boot";
588 Backup_Display_Name = Display_Name;
589 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600590 Can_Flash_Img = true;
me-cafebabe44e06ee2023-07-30 18:32:57 +0800591 } else if (Mount_Point == "/init_boot") {
592 Display_Name = "Init Boot";
593 Backup_Display_Name = Display_Name;
594 Can_Be_Backed_Up = true;
595 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500596 } else if (Mount_Point == "/recovery") {
597 Display_Name = "Recovery";
598 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600599 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500600 } else if (Mount_Point == "/system_image") {
601 Display_Name = "System Image";
602 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500603 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500604 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500605 } else if (Mount_Point == "/vendor_image") {
606 Display_Name = "Vendor Image";
607 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500608 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500609 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500610 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400611 }
612
Matt Mower2416a502016-04-12 19:54:46 -0500613 // Process TWRP fstab flags
614 if (strlen(twflags) > 0) {
615 string Prev_Display_Name = Display_Name;
616 string Prev_Storage_Name = Storage_Name;
617 string Prev_Backup_Display_Name = Backup_Display_Name;
618 Display_Name = "";
619 Storage_Name = "";
620 Backup_Display_Name = "";
621
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600622 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
623 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500624
625 bool has_display_name = !Display_Name.empty();
626 bool has_storage_name = !Storage_Name.empty();
627 bool has_backup_name = !Backup_Display_Name.empty();
628 if (!has_display_name) Display_Name = Prev_Display_Name;
629 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
630 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
631
632 if (has_display_name && !has_storage_name)
633 Storage_Name = Display_Name;
634 if (!has_display_name && has_storage_name)
635 Display_Name = Storage_Name;
636 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
637 Backup_Display_Name = Display_Name;
638 if (!has_display_name && has_backup_name)
639 Display_Name = Backup_Display_Name;
640 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600641
642 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
643 it = twrp_flags->find(Mount_Point);
644 if (it != twrp_flags->end()) {
645 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
646 int skip = 0;
647 string Flags = it->second.Flags;
648 strcpy(twrpflags, Flags.c_str());
649 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
650 skip += strlen("flags=");
651 char* flagptr = twrpflags;
652 flagptr += skip;
653 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
654 }
655 }
nkk7198fc3992017-12-16 16:26:42 +0200656
657 if (Mount_Point == "/persist" && Can_Be_Mounted) {
658 bool mounted = Is_Mounted();
659 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200660 TWFunc::Fixup_Time_On_Boot("/persist/time/");
661 if (!mounted)
662 UnMount(false);
663 }
664 }
665
Dees_Troy51127312012-09-08 13:08:49 -0400666 return true;
667}
668
Matt Mower72c87ce2016-04-26 14:34:56 -0500669void TWPartition::Partition_Post_Processing(bool Display_Error) {
670 if (Mount_Point == "/data")
671 Setup_Data_Partition(Display_Error);
672 else if (Mount_Point == "/cache")
673 Setup_Cache_Partition(Display_Error);
674}
675
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600676void TWPartition::ExcludeAll(const string& path) {
677 backup_exclusions.add_absolute_dir(path);
678 wipe_exclusions.add_absolute_dir(path);
679}
680
Matt Mower72c87ce2016-04-26 14:34:56 -0500681void TWPartition::Setup_Data_Partition(bool Display_Error) {
682 if (Mount_Point != "/data")
683 return;
684
685 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
686 UnMount(false);
687
688#ifdef TW_INCLUDE_CRYPTO
Darth99ab7cf52023-02-05 23:41:03 +0000689 #ifdef TW_PREPARE_DATA_MEDIA_EARLY
690 if (datamedia)
691 Setup_Data_Media();
692 #endif
Matt Mower72c87ce2016-04-26 14:34:56 -0500693 Can_Be_Encrypted = true;
694 char crypto_blkdev[255];
695 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
696 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400697 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500698 Decrypted_Block_Device = crypto_blkdev;
699 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
Darth99ab7cf52023-02-05 23:41:03 +0000700 #ifndef TW_PREPARE_DATA_MEDIA_EARLY
bigbiff4fa02b52021-12-30 17:01:44 -0500701 if (datamedia)
702 Setup_Data_Media();
Darth99ab7cf52023-02-05 23:41:03 +0000703 #endif
bigbiff7ba75002020-04-11 20:47:09 -0400704 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500705 } else if (!Mount(false)) {
706 if (Is_Present) {
me-cafebabeb0aab752022-06-10 01:45:40 +0800707 if (Key_Directory.empty()) {
708 set_partition_data(Use_Original_Path ? Original_Path.c_str() : Actual_Block_Device.c_str(), Crypto_Key_Location.c_str());
709 if (cryptfs_check_footer() == 0) {
710 Is_Encrypted = true;
711 Is_Decrypted = false;
712 Can_Be_Mounted = false;
713 Current_File_System = "emmc";
714 Setup_Image();
715 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
716 DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
717 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
718 DataManager::SetValue("tw_crypto_display", "");
719 if (datamedia)
720 Setup_Data_Media();
721 } else {
722 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
723 }
724 } else {
725 Is_Encrypted = true;
726 Is_Decrypted = false;
727 if (datamedia)
728 Setup_Data_Media();
729 }
Ethan Yonker93382822018-11-01 15:25:31 -0500730 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400731 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
732 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500733 }
734 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400735 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500736 int is_device_fbe;
737 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
Captain Throwback8a8e56c2021-10-01 15:12:24 -0400738 char crypto_state[255];
739 property_get("ro.crypto.state", crypto_state, "error");
740 if (!Decrypt_FBE_DE() && strcmp(crypto_state, "error") != 0) {
741 if (is_device_fbe == 1)
742 LOGERR("Unable to decrypt FBE device\n");
743 } else {
744 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Darth99ab7cf52023-02-05 23:41:03 +0000745 #ifndef TW_PREPARE_DATA_MEDIA_EARLY
bigbiff4fa02b52021-12-30 17:01:44 -0500746 if (datamedia)
747 Setup_Data_Media();
Darth99ab7cf52023-02-05 23:41:03 +0000748 #endif
mauronofrio9bf73352019-11-23 22:27:34 +0100749 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500750 }
751 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
752 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400753 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500754 }
755#else
756 if (datamedia) {
757 Setup_Data_Media();
758 Recreate_Media_Folder();
759 }
760#endif
761}
762
bigbiff7ba75002020-04-11 20:47:09 -0400763void TWPartition::Set_FBE_Status() {
764 DataManager::SetValue(TW_IS_DECRYPTED, 1);
765 Is_Encrypted = true;
766 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400767 if (Key_Directory.empty()) {
768 Is_FBE = false;
769 DataManager::SetValue(TW_IS_FBE, 0);
770 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500771 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400772 Is_FBE = true;
773 DataManager::SetValue(TW_IS_FBE, 1);
774 }
775}
776
Ethan Yonker93382822018-11-01 15:25:31 -0500777bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400778 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500779 DataManager::SetValue(TW_IS_FBE, 1);
Captain Throwback37c3aef2021-10-06 11:38:18 -0400780 PartitionManager.Set_Crypto_State();
781 PartitionManager.Set_Crypto_Type("file");
Ethan Yonker93382822018-11-01 15:25:31 -0500782 LOGINFO("File Based Encryption is present\n");
783#ifdef TW_INCLUDE_FBE
Noah Jacobson81d638d2019-04-28 00:10:07 -0400784 Is_FBE = true;
785 ExcludeAll(Mount_Point + "/convert_fbe");
786 ExcludeAll(Mount_Point + "/unencrypted");
787 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
788 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
789 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
790 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
791 ExcludeAll(Mount_Point + "/system/locksettings.db");
792 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
793 ExcludeAll(Mount_Point + "/misc/gatekeeper");
794 ExcludeAll(Mount_Point + "/misc/keystore");
795 ExcludeAll(Mount_Point + "/drm/kek.dat");
bigbiffa957f072021-03-07 18:20:29 -0500796 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt synthetic password
micky3872ec1df42021-10-14 14:53:06 +0200797 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.password.key");
798 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.pattern.key");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400799 ExcludeAll(Mount_Point + "/cache");
800 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400801 ExcludeAll(Mount_Point + "/gsi"); // cow devices
802
Noah Jacobson81d638d2019-04-28 00:10:07 -0400803 int retry_count = 3;
bigbiffdf53b6c2022-01-17 19:31:52 -0500804 while (!android::keystore::Decrypt_DE() && --retry_count)
Noah Jacobson81d638d2019-04-28 00:10:07 -0400805 usleep(2000);
806 if (retry_count > 0) {
Captain Throwback37c3aef2021-10-06 11:38:18 -0400807 PartitionManager.Set_Crypto_State();
Noah Jacobson81d638d2019-04-28 00:10:07 -0400808 Is_Encrypted = true;
809 Is_Decrypted = false;
810 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
811 string filename;
bigbiffdf53b6c2022-01-17 19:31:52 -0500812 int pwd_type = android::keystore::Get_Password_Type(0, filename);
Noah Jacobson81d638d2019-04-28 00:10:07 -0400813 if (pwd_type < 0) {
814 LOGERR("This TWRP does not have synthetic password decrypt support\n");
815 pwd_type = 0; // default password
Ethan Yonker93382822018-11-01 15:25:31 -0500816 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400817 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
818 std::vector<users_struct>::iterator iter;
819 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
820 for (iter = userList->begin(); iter != userList->end(); iter++) {
821 if (atoi((*iter).userId.c_str()) != 0) {
822 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
823 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
824 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
825 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
826 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
827 }
828 }
829 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
830 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
831 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
832 DataManager::SetValue("tw_crypto_display", "");
833 return true;
834 }
Ethan Yonker93382822018-11-01 15:25:31 -0500835#else
836 LOGERR("FBE found but FBE support not present in TWRP\n");
837#endif
838 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500839 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500840 return false;
841}
842
Matt Mower72c87ce2016-04-26 14:34:56 -0500843void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
844 if (Mount_Point != "/cache")
845 return;
846
847 if (!Mount(true))
848 return;
849
850 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
851 LOGINFO("Recreating /cache/recovery folder\n");
852 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
853 LOGERR("Could not create /cache/recovery\n");
854 }
855}
856
Matt Mower4ab42b12016-04-21 13:52:18 -0500857void TWPartition::Process_FS_Flags(const char *str) {
858 char *options = strdup(str);
859 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800860
Matt Mower4ab42b12016-04-21 13:52:18 -0500861 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800862
Matt Mower4ab42b12016-04-21 13:52:18 -0500863 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600864 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
865 char *equals = strstr(ptr, "=");
866 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500867
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600868 if (!equals)
869 name_len = strlen(ptr);
870 else
871 name_len = equals - ptr;
872
873 // There are some flags that we want to ignore in TWRP
874 bool found_match = false;
875 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
876 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
877 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800878 break;
879 }
880 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600881 if (found_match)
882 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800883
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600884 // mount_flags are never postfixed by '='
885 if (!equals) {
886 const struct flag_list* mount_flag = mount_flags;
887 for (; mount_flag->name; mount_flag++) {
888 if (strcmp(ptr, mount_flag->name) == 0) {
889 if (mount_flag->flag == MS_RDONLY)
890 Mount_Read_Only = true;
891 else
892 Mount_Flags |= (unsigned)mount_flag->flag;
893 found_match = true;
894 break;
895 }
896 }
897 if (found_match)
898 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500899 }
900
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600901 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
902 if (!Mount_Options.empty())
903 Mount_Options += ",";
904 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500905 }
906 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800907}
908
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600909void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
910 partition_fs_flags_struct flags;
911 flags.File_System = local_File_System;
912 flags.Mount_Flags = local_Mount_Flags;
913 flags.Mount_Options = local_Mount_Options;
914 fs_flags.push_back(flags);
915}
916
Matt Mower2416a502016-04-12 19:54:46 -0500917void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
918 switch (flag) {
919 case TWFLAG_ANDSEC:
920 Has_Android_Secure = val;
921 break;
922 case TWFLAG_BACKUP:
923 Can_Be_Backed_Up = val;
924 break;
925 case TWFLAG_BACKUPNAME:
926 Backup_Display_Name = str;
927 break;
928 case TWFLAG_BLOCKSIZE:
929 Format_Block_Size = (unsigned long)(atol(str));
930 break;
931 case TWFLAG_CANBEWIPED:
932 Can_Be_Wiped = val;
933 break;
934 case TWFLAG_CANENCRYPTBACKUP:
935 Can_Encrypt_Backup = val;
936 break;
937 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600938 case TWFLAG_WAIT:
939 case TWFLAG_VERIFY:
940 case TWFLAG_CHECK:
941 case TWFLAG_NOTRIM:
942 case TWFLAG_VOLDMANAGED:
943 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500944 // Do nothing
945 break;
946 case TWFLAG_DISPLAY:
947 Display_Name = str;
948 break;
949 case TWFLAG_ENCRYPTABLE:
950 case TWFLAG_FORCEENCRYPT:
951 Crypto_Key_Location = str;
952 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500953 case TWFLAG_FILEENCRYPTION:
954 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
955 // fileencryption=ice:aes-256-heh
956 {
957 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500958 size_t colon_loc = FBE.find(":");
959 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500960 property_set("fbe.contents", FBE.c_str());
961 property_set("fbe.filenames", "");
962 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500963 break;
964 }
Ethan Yonker93382822018-11-01 15:25:31 -0500965 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500966 FBE_contents = FBE.substr(0, colon_loc);
967 FBE_filenames = FBE.substr(colon_loc + 1);
968 property_set("fbe.contents", FBE_contents.c_str());
969 property_set("fbe.filenames", FBE_filenames.c_str());
970 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
971 }
972 break;
Captain Throwbackf74fe4f2022-02-08 12:45:01 -0500973 case TWFLAG_METADATA_ENCRYPTION:
974 // This flag isn't used by TWRP but is needed for FBEv2 metadata decryption
975 // metadata_encryption=aes-256-xts:wrappedkey_v0
976 {
977 std::string META = str;
978 size_t colon_loc = META.find(":");
979 if (colon_loc == std::string::npos) {
980 property_set("metadata.contents", META.c_str());
981 property_set("metadata.filenames", "");
982 LOGINFO("Metadata contents '%s', filenames ''\n", META.c_str());
983 break;
984 }
985 std::string META_contents, META_filenames;
986 META_contents = META.substr(0, colon_loc);
987 META_filenames = META.substr(colon_loc + 1);
988 property_set("metadata.contents", META_contents.c_str());
989 property_set("metadata.filenames", META_filenames.c_str());
990 LOGINFO("Metadata contents '%s', filenames '%s'\n", META_contents.c_str(), META_filenames.c_str());
991 }
992 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800993 case TWFLAG_WRAPPEDKEY:
bigbiff437d86f2021-09-26 16:57:14 -0400994 // no more processing needed. leaving it here in case we want to do something in the future
Peter Cai28ea7b02019-05-24 11:38:54 +0800995 break;
Matt Mower2416a502016-04-12 19:54:46 -0500996 case TWFLAG_FLASHIMG:
997 Can_Flash_Img = val;
998 break;
999 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -05001000 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -05001001 break;
1002 case TWFLAG_IGNOREBLKID:
1003 Ignore_Blkid = val;
1004 break;
1005 case TWFLAG_LENGTH:
1006 Length = atoi(str);
1007 break;
1008 case TWFLAG_MOUNTTODECRYPT:
1009 Mount_To_Decrypt = val;
1010 break;
Captain Throwback8d97d422022-02-08 15:31:44 -05001011 case TWFLAG_QUOTA:
1012 // Filesystem flag - TWRP does not need to process
1013 break;
Matt Mower2416a502016-04-12 19:54:46 -05001014 case TWFLAG_REMOVABLE:
1015 Removable = val;
1016 break;
Matt Mower2416a502016-04-12 19:54:46 -05001017 case TWFLAG_SETTINGSSTORAGE:
1018 Is_Settings_Storage = val;
1019 if (Is_Settings_Storage)
1020 Is_Storage = true;
1021 break;
1022 case TWFLAG_STORAGE:
1023 Is_Storage = val;
1024 break;
1025 case TWFLAG_STORAGENAME:
1026 Storage_Name = str;
1027 break;
1028 case TWFLAG_SUBPARTITIONOF:
1029 Is_SubPartition = true;
1030 SubPartition_Of = str;
1031 break;
1032 case TWFLAG_SYMLINK:
1033 Symlink_Path = str;
1034 break;
1035 case TWFLAG_USERDATAENCRYPTBACKUP:
1036 Use_Userdata_Encryption = val;
1037 if (Use_Userdata_Encryption)
1038 Can_Encrypt_Backup = true;
1039 break;
1040 case TWFLAG_USERMRF:
1041 Use_Rm_Rf = val;
1042 break;
1043 case TWFLAG_WIPEDURINGFACTORYRESET:
1044 Wipe_During_Factory_Reset = val;
1045 if (Wipe_During_Factory_Reset) {
1046 Can_Be_Wiped = true;
1047 Wipe_Available_in_GUI = true;
1048 }
1049 break;
1050 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001051 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -05001052 Wipe_Available_in_GUI = val;
1053 if (Wipe_Available_in_GUI)
1054 Can_Be_Wiped = true;
1055 break;
Ethan Yonker1b190162016-12-05 15:25:19 -06001056 case TWFLAG_SLOTSELECT:
1057 SlotSelect = true;
1058 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001059 case TWFLAG_ALTDEVICE:
1060 Alternate_Block_Device = str;
1061 break;
Peter Cai439d60c2019-10-17 08:49:10 +08001062 case TWFLAG_ADOPTED_MOUNT_DELAY:
1063 Adopted_Mount_Delay = atoi(str);
1064 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001065 case TWFLAG_KEYDIRECTORY:
1066 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001067 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001068 break;
Peter Caid68e6412019-11-02 19:22:38 +08001069 case TWFLAG_DM_USE_ORIGINAL_PATH:
1070 Use_Original_Path = true;
1071 break;
bigbiff998f8392021-08-06 19:19:33 -04001072 case TWFLAG_LOGICAL:
1073 Is_Super = true;
1074 break;
Darth99fb13af2023-04-07 23:32:45 +01001075 case TWFLAG_FS_COMPRESS:
1076 #ifdef TW_ENABLE_FS_COMPRESSION
1077 Needs_Fs_Compress = true;
1078 LOGINFO("Enabling 'fs compression'\n");
1079 #else
1080 LOGINFO("Ignoring the 'fscompress' fstab flag\n");
1081 #endif
1082 break;
Matt Mower2416a502016-04-12 19:54:46 -05001083 default:
1084 // Should not get here
1085 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1086 break;
1087 }
1088}
Dees_Troy51127312012-09-08 13:08:49 -04001089
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001090void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001091 char separator[2] = {'\n', 0};
1092 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001093 char source_separator = ';';
1094
1095 if (fstab_ver == 2)
1096 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001097
1098 // Semicolons within double-quotes are not forbidden, so replace
1099 // only the semicolons intended as separators with '\n' for strtok
1100 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1101 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001102 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001103 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001104 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001105 }
1106
Matt Mower2416a502016-04-12 19:54:46 -05001107 // Avoid issues with potentially nested strtok by using strtok_r
1108 ptr = strtok_r(flags, separator, &savep);
1109 while (ptr) {
1110 int ptr_len = strlen(ptr);
1111 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001112
Matt Mower2416a502016-04-12 19:54:46 -05001113 for (; tw_flag->name; tw_flag++) {
1114 int flag_len = strlen(tw_flag->name);
1115
1116 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1117 bool flag_val = false;
1118
1119 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1120 && ptr[flag_len] != '=') {
1121 // Handle flags with same starting string
1122 // (e.g. backup and backupname)
1123 continue;
1124 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1125 // Handle flags with dual format: Part 1
1126 // (e.g. backup and backup=y. backup=y handled here)
1127 ptr += flag_len + 1;
1128 TWFunc::Strip_Quotes(ptr);
1129 // Skip flags with empty argument
1130 // (e.g. backup=)
1131 if (strlen(ptr) == 0) {
1132 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1133 break;
1134 }
1135 flag_val = strchr("yY1", *ptr) != NULL;
1136 } else if (ptr_len == flag_len
1137 && (tw_flag->name)[flag_len-1] == '=') {
1138 // Skip flags missing argument after =
1139 // (e.g. backupname=)
1140 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1141 break;
1142 } else if (ptr_len > flag_len
1143 && (tw_flag->name)[flag_len-1] == '=') {
1144 // Handle arguments to flags
1145 // (e.g. backupname="My Stuff")
1146 ptr += flag_len;
1147 TWFunc::Strip_Quotes(ptr);
1148 // Skip flags with empty argument
1149 // (e.g. backupname="")
1150 if (strlen(ptr) == 0) {
1151 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1152 break;
1153 }
1154 } else if (ptr_len == flag_len) {
1155 // Handle flags with dual format: Part 2
1156 // (e.g. backup and backup=y. backup handled here)
1157 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001158 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001159 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1160 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001161 }
Matt Mower2416a502016-04-12 19:54:46 -05001162
1163 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1164 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001165 }
Matt Mower2416a502016-04-12 19:54:46 -05001166 }
1167 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001168 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001169 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001170 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001171 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001172 }
Matt Mower2416a502016-04-12 19:54:46 -05001173 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001174 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001175}
1176
Dees_Troy5bf43922012-09-07 16:07:55 -04001177bool TWPartition::Is_File_System(string File_System) {
1178 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001179 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001180 File_System == "ext4" ||
1181 File_System == "vfat" ||
1182 File_System == "ntfs" ||
1183 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001184 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001185 File_System == "f2fs" ||
GarfieldHanc60a2082021-11-21 23:46:20 +08001186 File_System == "erofs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001187 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001188 File_System == "auto")
1189 return true;
1190 else
1191 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001192}
1193
Dees_Troy5bf43922012-09-07 16:07:55 -04001194bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001195 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001196 return true;
1197 else
1198 return false;
1199}
1200
Dees_Troy51127312012-09-08 13:08:49 -04001201bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001202 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1203 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001204 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001205 if (mkdir(Path.c_str(), 0777) == -1) {
1206 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001207 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001208 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001209 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001210 return false;
1211 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001212 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001213 return true;
1214 }
1215 }
1216 return true;
1217}
1218
Dees_Troy5bf43922012-09-07 16:07:55 -04001219void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001220 Can_Be_Mounted = true;
1221 Can_Be_Wiped = true;
1222
Dees_Troy5bf43922012-09-07 16:07:55 -04001223 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001224 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001225 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001226}
1227
Ethan Yonker1b190162016-12-05 15:25:19 -06001228void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001229 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1230 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001231 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001232 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001233 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001234 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001235 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001236 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 -04001237}
1238
Dees_Troye58d5262012-09-21 12:27:57 -04001239void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001240 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001241 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001242 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001243 Has_Android_Secure = true;
1244 Symlink_Path = Mount_Point + "/.android_secure";
1245 Symlink_Mount_Point = "/and-sec";
1246 Backup_Path = Symlink_Mount_Point;
1247 Make_Dir("/and-sec", true);
1248 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001249 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001250}
1251
that9e0593e2014-10-08 00:01:24 +02001252void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001253 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001254 if (Storage_Name.empty() || Storage_Name == "Data")
1255 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001256 Has_Data_Media = true;
1257 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001258 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001259 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001260 if (Mount_Point == "/data") {
1261 Is_Settings_Storage = true;
1262 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1263 Make_Dir("/emmc", false);
1264 Symlink_Mount_Point = "/emmc";
1265 } else {
1266 Make_Dir("/sdcard", false);
1267 Symlink_Mount_Point = "/sdcard";
1268 }
Darth99ab7cf52023-02-05 23:41:03 +00001269 #ifdef TW_PREPARE_DATA_MEDIA_EARLY
1270 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1271 #else
bigbiff4fa02b52021-12-30 17:01:44 -05001272 Mount(false);
1273 if (TWFunc::Path_Exists(Mount_Point + "/media/0")) {
Darth99ab7cf52023-02-05 23:41:03 +00001274 #endif
Ethan Yonker66a19492015-12-10 10:19:45 -06001275 Storage_Path = Mount_Point + "/media/0";
1276 Symlink_Path = Storage_Path;
1277 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1278 UnMount(true);
1279 }
1280 DataManager::SetValue("tw_has_internal", 1);
1281 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001282 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001283 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 +01001284 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001285 backup_exclusions.add_absolute_dir("/data/cache");
nijel87e5bc9b2022-01-14 10:01:32 -05001286 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 +08001287 backup_exclusions.add_absolute_dir("/data/extm"); //exclude this dir to prevent "error 255" on MIUI
me-cafebabe49f25fa2023-07-30 18:25:33 +08001288 backup_exclusions.add_absolute_dir("/data/gsi"); // Contains huge files (DSU System image + Userdata image), and won't work after restoration (requires configuration files in metadata)
Ethan Yonker6355b562017-05-01 09:42:17 -05001289 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001290 ExcludeAll(Mount_Point + "/system/storage.xml");
Darth9cc683e72022-08-09 12:54:40 +01001291
Darth92fa94a72023-03-16 17:14:08 +00001292 backup_exclusions.add_absolute_dir("/data/system/users/0/package-restrictions.xml");
1293
Darth9cc683e72022-08-09 12:54:40 +01001294 // board-customisable exclusions
1295 #ifdef TW_BACKUP_EXCLUSIONS
1296 std::vector<std::string> user_extra_exclusions = TWFunc::Split_String(TW_BACKUP_EXCLUSIONS, ",");
1297 std::string s1;
1298 for (const std::string& extra_x : user_extra_exclusions) {
1299 s1 = android::base::Trim(extra_x);
1300 if (!s1.empty()) {
1301 backup_exclusions.add_absolute_dir(s1);
1302 LOGINFO("Adding user-defined path '%s' to the backup exclusions\n", s1.c_str());
1303 }
1304 }
1305 #endif
Ethan Yonker6277c792014-09-15 14:54:30 -05001306 } else {
nkk717aa6fc62017-03-24 18:28:03 +02001307 int i;
1308 string path;
1309 for (i = 2; i <= 9; i++) {
1310 path = "/sdcard" + TWFunc::to_string(i);
1311 if (!TWFunc::Path_Exists(path)) {
1312 Make_Dir(path, false);
1313 Symlink_Mount_Point = path;
1314 LOGINFO("'%s' data/media emulated storage symlinked to %s.\n", Mount_Point.c_str(), Symlink_Mount_Point.c_str());
1315 break;
1316 }
1317 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001318 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1319 Storage_Path = Mount_Point + "/media/0";
1320 Symlink_Path = Storage_Path;
1321 UnMount(true);
1322 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001323 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001324 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001325}
1326
Dees_Troy5bf43922012-09-07 16:07:55 -04001327void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001328 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001329
Peter Caid68e6412019-11-02 19:22:38 +08001330 Original_Path = Block;
1331
Dees_Troy5bf43922012-09-07 16:07:55 -04001332 strcpy(device, Block.c_str());
1333 memset(realDevice, 0, sizeof(realDevice));
1334 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1335 {
1336 strcpy(device, realDevice);
1337 memset(realDevice, 0, sizeof(realDevice));
1338 }
1339
bigbiff998f8392021-08-06 19:19:33 -04001340 Block = device;
1341 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001342}
1343
Kjell Braden3126a112016-06-19 16:58:15 +00001344bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001345 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001346 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001347 int retry_count = 5;
1348 while (retry_count > 0 && !Mount(false)) {
1349 usleep(500000);
1350 retry_count--;
1351 }
Kjell Braden3126a112016-06-19 16:58:15 +00001352 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001353 }
Kjell Braden3126a112016-06-19 16:58:15 +00001354 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001355}
1356
Dees_Troy38bd7602012-09-14 13:33:53 -04001357bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1358 FILE *fp = NULL;
1359 char line[255];
1360
1361 fp = fopen("/proc/mtd", "rt");
1362 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001363 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001364 return false;
1365 }
1366
1367 while (fgets(line, sizeof(line), fp) != NULL)
1368 {
1369 char device[32], label[32];
1370 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001371 int deviceId;
1372
1373 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1374
1375 // Skip header and blank lines
1376 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1377 continue;
1378
1379 // Strip off the trailing " from the label
1380 label[strlen(label)-1] = '\0';
1381
1382 if (strcmp(label, MTD_Name.c_str()) == 0) {
1383 // We found our device
1384 // Strip off the trailing : from the device
1385 device[strlen(device)-1] = '\0';
1386 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1387 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1388 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001389 fclose(fp);
1390 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001391 }
1392 }
1393 }
1394 fclose(fp);
1395
1396 return false;
1397}
1398
Dees_Troy51127312012-09-08 13:08:49 -04001399bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1400 struct statfs st;
1401 string Local_Path = Mount_Point + "/.";
1402
1403 if (!Mount(Display_Error))
1404 return false;
1405
1406 if (statfs(Local_Path.c_str(), &st) != 0) {
1407 if (!Removable) {
1408 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001409 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001410 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001411 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001412 }
1413 return false;
1414 }
1415 Size = (st.f_blocks * st.f_bsize);
1416 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1417 Free = (st.f_bfree * st.f_bsize);
1418 Backup_Size = Used;
1419 return true;
1420}
1421
1422bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001423 FILE* fp;
1424 char command[255], line[512];
1425 int include_block = 1;
1426 unsigned int min_len;
1427
1428 if (!Mount(Display_Error))
1429 return false;
1430
Dees_Troy38bd7602012-09-14 13:33:53 -04001431 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001432 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001433 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001434 fp = fopen("/tmp/dfoutput.txt", "rt");
1435 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001436 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001437 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001438 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001439
1440 while (fgets(line, sizeof(line), fp) != NULL)
1441 {
1442 unsigned long blocks, used, available;
1443 char device[64];
1444 char tmpString[64];
1445
1446 if (strncmp(line, "Filesystem", 10) == 0)
1447 continue;
1448 if (strlen(line) < min_len) {
1449 include_block = 0;
1450 continue;
1451 }
1452 if (include_block) {
1453 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1454 } else {
1455 // The device block string is so long that the df information is on the next line
1456 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001457 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001458 while (tmpString[space_count] == 32)
1459 space_count++;
1460 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1461 }
1462
1463 // Adjust block size to byte size
1464 Size = blocks * 1024ULL;
1465 Used = used * 1024ULL;
1466 Free = available * 1024ULL;
1467 Backup_Size = Used;
1468 }
1469 fclose(fp);
1470 return true;
1471}
1472
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001473unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001474 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001475
1476 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001477}
1478
Dees_Troy5bf43922012-09-07 16:07:55 -04001479bool TWPartition::Find_Partition_Size(void) {
1480 FILE* fp;
1481 char line[512];
1482 string tmpdevice;
1483
igoriok87e3d932013-01-31 21:03:53 +02001484 fp = fopen("/proc/dumchar_info", "rt");
1485 if (fp != NULL) {
1486 while (fgets(line, sizeof(line), fp) != NULL)
1487 {
1488 char label[32], device[32];
1489 unsigned long size = 0;
1490
thatd43bf2d2014-09-21 23:13:02 +02001491 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001492
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001493 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001494 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1495 continue;
1496
1497 tmpdevice = "/dev/";
1498 tmpdevice += label;
1499 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1500 Size = size;
1501 fclose(fp);
1502 return true;
1503 }
1504 }
1505 }
1506
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001507 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1508 if (ioctl_size) {
1509 Size = ioctl_size;
1510 return true;
1511 }
1512
Dees_Troy5bf43922012-09-07 16:07:55 -04001513 // In this case, we'll first get the partitions we care about (with labels)
1514 fp = fopen("/proc/partitions", "rt");
1515 if (fp == NULL)
1516 return false;
1517
1518 while (fgets(line, sizeof(line), fp) != NULL)
1519 {
1520 unsigned long major, minor, blocks;
1521 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001522
Dees_Troy63c8df72012-09-10 14:02:05 -04001523 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001524 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1525
1526 tmpdevice = "/dev/block/";
1527 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001528 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001529 // Adjust block size to byte size
1530 Size = blocks * 1024ULL;
1531 fclose(fp);
1532 return true;
1533 }
1534 }
1535 fclose(fp);
1536 return false;
1537}
1538
Dees_Troy5bf43922012-09-07 16:07:55 -04001539bool TWPartition::Is_Mounted(void) {
1540 if (!Can_Be_Mounted)
1541 return false;
1542
1543 struct stat st1, st2;
1544 string test_path;
1545
1546 // Check to see if the mount point directory exists
1547 test_path = Mount_Point + "/.";
1548 if (stat(test_path.c_str(), &st1) != 0) return false;
1549
1550 // Check to see if the directory above the mount point exists
1551 test_path = Mount_Point + "/../.";
1552 if (stat(test_path.c_str(), &st2) != 0) return false;
1553
1554 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1555 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001556 return ret;
1557}
1558
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001559bool TWPartition::Is_File_System_Writable(void) {
1560 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1561 return false;
1562
1563 string test_path = Mount_Point + "/.";
1564 return (access(test_path.c_str(), W_OK) == 0);
1565}
1566
Dees_Troy5bf43922012-09-07 16:07:55 -04001567bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001568 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001569 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001570
Dees_Troy5bf43922012-09-07 16:07:55 -04001571 if (Is_Mounted()) {
1572 return true;
1573 } else if (!Can_Be_Mounted) {
1574 return false;
1575 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001576
1577 Find_Actual_Block_Device();
1578
1579 // Check the current file system before mounting
1580 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001581 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1582 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 +00001583 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001584 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001585 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001586 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001587 Current_File_System = "vfat";
1588 } else {
1589#ifdef TW_NO_EXFAT_FUSE
1590 UnMount(false);
1591 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1592 // Some kernels let us mount vfat as exfat which doesn't work out too well
1593#else
1594 exfat_mounted = 1;
1595#endif
1596 }
1597 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001598
Captain Throwback47bf7202020-10-06 17:39:39 -04001599 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 -05001600 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001601 string Ntfsmount_Binary = "";
1602
bigbiffad58e1b2020-07-06 20:24:34 -04001603 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001604 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001605 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001606 Ntfsmount_Binary = "mount.ntfs";
1607
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001608 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001609 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001610 else
bigbiffad58e1b2020-07-06 20:24:34 -04001611 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001612 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001613
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001614 if (TWFunc::Exec_Cmd(cmd) == 0) {
1615 return true;
1616 } else {
1617 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1618 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001619 } else {
1620 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1621 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001622 }
1623
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001624 if (Mount_Read_Only)
1625 flags |= MS_RDONLY;
1626
Dees_Troy22042032012-12-18 21:23:08 +00001627 if (Fstab_File_System == "yaffs2") {
1628 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001629 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1630 if (Mount_Read_Only)
1631 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001632 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1633 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1634 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001635 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001636 else
1637 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1638 return false;
1639 } else {
1640 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1641 return true;
1642 }
1643 } else {
1644 struct stat st;
1645 string test_path = Mount_Point;
1646 if (stat(test_path.c_str(), &st) < 0) {
1647 if (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_Troy76543db2013-06-19 16:24:30 +00001649 else
1650 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1651 return false;
1652 }
1653 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1654 if (new_mode != st.st_mode) {
1655 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1656 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1657 if (Display_Error)
1658 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1659 else
1660 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1661 return false;
1662 }
1663 }
Dees_Troy22042032012-12-18 21:23:08 +00001664 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001665 }
thatc7572eb2015-03-31 18:55:30 +02001666 }
1667
1668 string mount_fs = Current_File_System;
1669 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1670 mount_fs = "texfat";
1671
1672 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001673 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1674 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001675#ifdef TW_NO_EXFAT_FUSE
1676 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001677 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001678 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001679 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001680 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001681 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001682 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001683 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 +00001684 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001685 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001686 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001687#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001688 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001689 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001690 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001691 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1692 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 +00001693 return false;
1694#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001695 }
1696#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001697 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001698
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001699 if (Removable)
1700 Update_Size(Display_Error);
1701
bigbiff4fa02b52021-12-30 17:01:44 -05001702 if (!Symlink_Mount_Point.empty()) {
bigbiffbe4f46c2021-04-24 11:48:54 -04001703 if (!Bind_Mount(false))
1704 return false;
1705 }
1706 return true;
1707}
1708
1709bool TWPartition::Bind_Mount(bool Display_Error) {
1710 if (TWFunc::Path_Exists(Symlink_Path)) {
1711 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1712 return false;
1713 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001714 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001715 return true;
1716}
1717
1718bool TWPartition::UnMount(bool Display_Error) {
1719 if (Is_Mounted()) {
1720 int never_unmount_system;
1721
1722 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001723 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001724 return true; // Never unmount system if you're not supposed to unmount it
1725
Matt Mowera8e6d832017-02-14 20:20:59 -06001726 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001727 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001728
Dees_Troy38bd7602012-09-14 13:33:53 -04001729 if (!Symlink_Mount_Point.empty())
1730 umount(Symlink_Mount_Point.c_str());
1731
Dees_Troyb05ddee2013-01-28 20:24:50 +00001732 umount(Mount_Point.c_str());
1733 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001734 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001735 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001736 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001737 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001738 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001739 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001740 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001741 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001742 } else {
1743 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001744 }
1745}
1746
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001747bool TWPartition::ReMount(bool Display_Error) {
1748 if (UnMount(Display_Error))
1749 return Mount(Display_Error);
1750 return false;
1751}
1752
1753bool TWPartition::ReMount_RW(bool Display_Error) {
1754 // No need to remount if already mounted rw
1755 if (Is_File_System_Writable())
1756 return true;
1757
1758 bool ro = Mount_Read_Only;
1759 int flags = Mount_Flags;
1760
1761 Mount_Read_Only = false;
1762 Mount_Flags &= ~MS_RDONLY;
1763
1764 bool ret = ReMount(Display_Error);
1765
1766 Mount_Read_Only = ro;
1767 Mount_Flags = flags;
1768
1769 return ret;
1770}
1771
me-cafebabe76693202022-07-29 06:12:38 +08001772bool TWPartition::BlkDiscard() {
1773 string cmd;
1774 LOGINFO("Perform BLKDISCARD on block device %s\n", Actual_Block_Device.c_str());
1775 cmd = "/system/bin/toybox blkdiscard " + Actual_Block_Device;
1776 return (TWFunc::Exec_Cmd(cmd) == 0);
1777}
1778
Gary Peck43acadf2012-11-21 21:19:01 -08001779bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001780 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001781 int check;
Dees_Troy16c2b312013-01-15 16:51:18 +00001782
Dees_Troy38bd7602012-09-14 13:33:53 -04001783 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001784 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001785 return false;
1786 }
1787
Dees_Troyc51f1f92012-09-20 15:32:13 -04001788 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001789 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001790
bigbiff4a60bee2021-01-23 14:08:03 -05001791 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1792 if (tw_get_default_metadata(PartitionManager.Get_Android_Root_Path().c_str()) != 0) {
1793 gui_msg(Msg(msg::kWarning, "restore_system_context=Unable to get default context for {1} -- Android may not boot.")(PartitionManager.Get_Android_Root_Path()));
1794 }
1795 }
1796
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001797 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001798 wiped = Wipe_Data_Without_Wiping_Media();
bigbiff25d25b92020-06-19 16:07:38 -04001799 if (Mount_Point == "/data" && TWFunc::get_log_dir() == DATA_LOGS_DIR) {
1800 bool created = PartitionManager.Recreate_Logs_Dir();
1801 if (!created)
1802 LOGERR("Unable to create log directory for TWRP\n");
bigbiff7ba75002020-04-11 20:47:09 -04001803 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001804 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001805 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001806 DataManager::GetValue(TW_RM_RF_VAR, check);
Hashcodedabfd492013-08-29 22:45:30 -07001807 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001808 wiped = Wipe_RMRF();
1809 else if (New_File_System == "ext4")
1810 wiped = Wipe_EXT4();
1811 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001812 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001813 else if (New_File_System == "exfat")
1814 wiped = Wipe_EXFAT();
Captain Throwback47bf7202020-10-06 17:39:39 -04001815 else if (New_File_System == "ntfs" || Current_File_System == "tntfs")
1816 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001817 else if (New_File_System == "yaffs2")
1818 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001819 else if (New_File_System == "f2fs")
1820 wiped = Wipe_F2FS();
Captain Throwback47bf7202020-10-06 17:39:39 -04001821 else if (New_File_System == "vfat")
1822 wiped = Wipe_FAT();
Dees_Troy16c2b312013-01-15 16:51:18 +00001823 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001824 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 +00001825 return false;
1826 }
1827 update_crypt = wiped;
bigbiff7ba75002020-04-11 20:47:09 -04001828 update_crypt = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001829 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001830
Gary Pecke8bc5d72012-12-21 06:45:25 -08001831 if (wiped) {
Mohd Faraze1d72622020-06-15 00:28:32 +05301832 if (Mount_Point == "/cache" && TWFunc::get_log_dir() != DATA_LOGS_DIR)
1833 DataManager::Output_Version();
1834
bigbiff4a60bee2021-01-23 14:08:03 -05001835 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
1836 tw_set_default_metadata(PartitionManager.Get_Android_Root_Path().c_str());
1837 }
Dees_Troy16c2b312013-01-15 16:51:18 +00001838 if (update_crypt) {
1839 Setup_File_System(false);
1840 if (Is_Encrypted && !Is_Decrypted) {
1841 // just wiped an encrypted partition back to its unencrypted state
1842 Is_Encrypted = false;
1843 Is_Decrypted = false;
1844 Decrypted_Block_Device = "";
1845 if (Mount_Point == "/data") {
1846 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1847 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1848 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001849 }
1850 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001851
Captain Throwback63573b52021-10-02 20:47:33 -04001852 if (Is_Storage && Mount(false) && !Is_FBE)
bigbiffbe4f46c2021-04-24 11:48:54 -04001853 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001854 }
Matt Mower209c9632016-01-20 12:08:35 -06001855
Gary Pecke8bc5d72012-12-21 06:45:25 -08001856 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001857}
1858
Gary Peck43acadf2012-11-21 21:19:01 -08001859bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001860 if (Is_File_System(Current_File_System))
1861 return Wipe(Current_File_System);
1862 else
1863 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001864}
1865
Dees_Troye58d5262012-09-21 12:27:57 -04001866bool TWPartition::Wipe_AndSec(void) {
1867 if (!Has_Android_Secure)
1868 return false;
1869
Dees_Troye58d5262012-09-21 12:27:57 -04001870 if (!Mount(true))
1871 return false;
1872
Ethan Yonker74db1572015-10-28 12:44:49 -05001873 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001874 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001875 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001876}
1877
bigbiffaed1bdf2021-08-03 18:21:39 -04001878bool TWPartition::Wipe_Data_Cache(void) {
1879 if (!Mount(true))
1880 return false;
1881 gui_msg(Msg("wiping=Wiping {1}")(Mount_Point + "/cache/"));
1882 TWFunc::removeDir(Mount_Point + "/cache/", true);
1883 return true;
1884}
1885
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001886bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001887 if (Mount_Read_Only)
1888 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04001889 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/system/bin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001890 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001891 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 -05001892 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001893 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/fsck.exfat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001894 return true;
bigbiffad58e1b2020-07-06 20:24:34 -04001895 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/system/bin/fsck.f2fs"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001896 return true;
Captain Throwback47bf7202020-10-06 17:39:39 -04001897 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 -05001898 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001899 return false;
1900}
1901
1902bool TWPartition::Repair() {
1903 string command;
1904
1905 if (Current_File_System == "vfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001906 if (!TWFunc::Path_Exists("/system/bin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001907 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001908 return false;
1909 }
1910 if (!UnMount(true))
1911 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001912 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001913 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001914 command = "/system/bin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001915 LOGINFO("Repair command: %s\n", command.c_str());
1916 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001917 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001918 return true;
1919 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001920 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001921 return false;
1922 }
1923 }
1924 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
bigbiffad58e1b2020-07-06 20:24:34 -04001925 if (!TWFunc::Path_Exists("/system/bin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001926 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001927 return false;
1928 }
1929 if (!UnMount(true))
1930 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001931 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001932 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001933 command = "/system/bin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001934 LOGINFO("Repair command: %s\n", command.c_str());
1935 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001936 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001937 return true;
1938 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001939 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001940 return false;
1941 }
1942 }
1943 if (Current_File_System == "exfat") {
bigbiffad58e1b2020-07-06 20:24:34 -04001944 if (!TWFunc::Path_Exists("/system/bin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001945 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001946 return false;
1947 }
1948 if (!UnMount(true))
1949 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001950 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001951 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001952 command = "/system/bin/fsck.exfat " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001953 LOGINFO("Repair command: %s\n", command.c_str());
1954 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001955 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001956 return true;
1957 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001958 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001959 return false;
1960 }
1961 }
1962 if (Current_File_System == "f2fs") {
bigbiffad58e1b2020-07-06 20:24:34 -04001963 if (!TWFunc::Path_Exists("/system/bin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001964 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001965 return false;
1966 }
1967 if (!UnMount(true))
1968 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001969 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001970 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001971 command = "/system/bin/fsck.f2fs " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001972 LOGINFO("Repair command: %s\n", command.c_str());
1973 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001974 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001975 return true;
1976 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001977 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001978 return false;
1979 }
1980 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001981 if (Current_File_System == "ntfs" || Current_File_System == "tntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001982 string Ntfsfix_Binary;
bigbiffad58e1b2020-07-06 20:24:34 -04001983 if (TWFunc::Path_Exists("/system/bin/ntfsfix"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001984 Ntfsfix_Binary = "ntfsfix";
bigbiffad58e1b2020-07-06 20:24:34 -04001985 else if (TWFunc::Path_Exists("/system/bin/fsck.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001986 Ntfsfix_Binary = "fsck.ntfs";
1987 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001988 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001989 return false;
1990 }
1991 if (!UnMount(true))
1992 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001993 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001994 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04001995 command = "/system/bin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001996 LOGINFO("Repair command: %s\n", command.c_str());
1997 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001998 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001999 return true;
2000 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002001 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002002 return false;
2003 }
2004 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05002005 return false;
2006}
2007
Ethan Yonkera2719152015-05-28 09:44:41 -05002008bool TWPartition::Can_Resize() {
2009 if (Mount_Read_Only)
2010 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002011 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 -05002012 return true;
2013 return false;
2014}
2015
2016bool TWPartition::Resize() {
2017 string command;
2018
2019 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
2020 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002021 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
2022 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05002023 return false;
2024 }
bigbiffad58e1b2020-07-06 20:24:34 -04002025 if (!TWFunc::Path_Exists("/system/bin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002026 LOGINFO("resize2fs does not exist! Cannot resize!\n");
2027 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05002028 return false;
2029 }
2030 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05002031 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05002032 if (!Repair())
2033 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05002034 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05002035 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002036 command = "/system/bin/resize2fs " + Actual_Block_Device;
Ethan Yonkera2719152015-05-28 09:44:41 -05002037 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06002038 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
2039 if (Actual_Size == 0)
2040 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05002041
Ethan Yonkera2719152015-05-28 09:44:41 -05002042 unsigned long long Block_Count;
2043 if (Length < 0) {
2044 // Reduce overall size by this length
2045 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
2046 } else {
2047 // This is the size, not a size reduction
2048 Block_Count = ((unsigned long long)(Length) / 1024LLU);
2049 }
2050 char temp[256];
2051 sprintf(temp, "%llu", Block_Count);
2052 command += " ";
2053 command += temp;
2054 command += "K";
2055 }
2056 LOGINFO("Resize command: %s\n", command.c_str());
2057 if (TWFunc::Exec_Cmd(command) == 0) {
2058 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05002059 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05002060 return true;
2061 } else {
2062 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05002063 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05002064 return false;
2065 }
2066 }
2067 return false;
2068}
2069
bigbiffce8f83c2015-12-12 18:30:21 -05002070bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
2071 if (Backup_Method == BM_FILES)
2072 return Backup_Tar(part_settings, tar_fork_pid);
2073 else if (Backup_Method == BM_DD)
2074 return Backup_Image(part_settings);
2075 else if (Backup_Method == BM_FLASH_UTILS)
2076 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00002077 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002078 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002079}
2080
bigbiffce8f83c2015-12-12 18:30:21 -05002081bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06002082 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002083 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08002084
bigbiffce8f83c2015-12-12 18:30:21 -05002085 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002086
2087 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05002088 return Restore_Tar(part_settings);
2089 else if (Is_Image(Restore_File_System))
2090 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002091
2092 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
2093 return false;
2094}
2095
bigbiffce8f83c2015-12-12 18:30:21 -05002096string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002097 size_t first_period, second_period;
2098 string Restore_File_System;
2099
Gary Peck43acadf2012-11-21 21:19:01 -08002100 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002101 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08002102 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002103 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002104 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002105 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002106 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08002107 second_period = Restore_File_System.find(".");
2108 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002109 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02002110 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08002111 }
2112 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06002113 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002114 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04002115}
2116
2117string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05002118 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04002119 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05002120 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04002121 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05002122 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04002123 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05002124 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04002125 return "flash_utils";
2126 else
2127 return "undefined";
2128 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04002129}
2130
2131bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002132 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04002133 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04002134 return 1;
2135}
2136
2137bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002138 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05002139 bool ret = false;
2140 BasePartition* base_partition = make_partition();
2141
2142 if (!base_partition->PreWipeEncryption())
2143 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002144
dianlujitao4879b372018-12-03 18:45:47 +08002145 Find_Actual_Block_Device();
2146 if (!Is_Present) {
2147 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
2148 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2149 return false;
2150 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002151
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002152#ifdef TW_INCLUDE_CRYPTO
bigbiff7ba75002020-04-11 20:47:09 -04002153 if (!UnMount(true))
2154 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002155 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06002156 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002157 LOGERR("Error deleting crypto block device, continuing anyway.\n");
2158 }
2159 }
2160#endif
dianlujitao4879b372018-12-03 18:45:47 +08002161 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05002162 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00002163 Is_Decrypted = false;
2164 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08002165 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002166 Has_Data_Media = Save_Data_Media;
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06002167 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05002168#ifndef TW_OEM_BUILD
bigbiff25d25b92020-06-19 16:07:38 -04002169 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 -05002170#endif
bigbiff2d548672021-07-09 20:08:44 -04002171 if (Is_FBE) {
2172 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 -04002173 } else {
2174 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
2175 if (Mount(false))
2176 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2177 }
bigbiff2d548672021-07-09 20:08:44 -04002178 }
2179
Ethan Yonker93382822018-11-01 15:25:31 -05002180 ret = true;
2181 if (!Key_Directory.empty())
2182 ret = PartitionManager.Wipe_By_Path(Key_Directory);
2183 if (ret)
2184 ret = base_partition->PostWipeEncryption();
2185 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002186 } else {
2187 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05002188 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06002189 if (Has_Data_Media && Mount(false))
2190 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05002191 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04002192 }
Ethan Yonker93382822018-11-01 15:25:31 -05002193exit:
2194 delete base_partition;
2195 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002196}
2197
2198void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002199 const char* type;
2200 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04002201
Dees_Troy68cab492012-12-12 19:29:35 +00002202 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
2203 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04002204
Dees_Troy38bd7602012-09-14 13:33:53 -04002205 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04002206 if (!Is_Present)
2207 return;
Dees_Troy51127312012-09-08 13:08:49 -04002208
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002209 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2210 if (blkid_do_fullprobe(pr)) {
2211 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002212 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002213 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002214 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002215
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002216 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002217 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002218 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002219 return;
2220 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002221
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002222 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002223 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002224 if (fs_flags.size() > 1) {
2225 std::vector<partition_fs_flags_struct>::iterator iter;
2226 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2227
2228 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2229 if (iter->File_System == Current_File_System) {
2230 found = iter;
2231 break;
2232 }
2233 }
2234 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2235 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2236 Mount_Flags = found->Mount_Flags;
2237 Mount_Options = found->Mount_Options;
2238 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2239 }
2240 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002241}
2242
dianlujitao4879b372018-12-03 18:45:47 +08002243bool TWPartition::Wipe_EXTFS(string File_System) {
bigbiff7ba75002020-04-11 20:47:09 -04002244 if (!UnMount(true))
2245 return false;
2246
dianlujitao4879b372018-12-03 18:45:47 +08002247#if PLATFORM_SDK_VERSION < 28
bigbiffad58e1b2020-07-06 20:24:34 -04002248 if (!TWFunc::Path_Exists("/system/bin/mke2fs"))
dianlujitao4879b372018-12-03 18:45:47 +08002249#else
bigbiffad58e1b2020-07-06 20:24:34 -04002250 if (!TWFunc::Path_Exists("/system/bin/mke2fs") || !TWFunc::Path_Exists("/system/bin/e2fsdroid"))
dianlujitao4879b372018-12-03 18:45:47 +08002251#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002252 return Wipe_RMRF();
2253
dianlujitao4879b372018-12-03 18:45:47 +08002254 int ret;
2255 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002256
Ethan Yonker25f20c12014-10-14 09:04:43 -05002257 Find_Actual_Block_Device();
2258 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002259 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2260 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002261 return false;
2262 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002263
dianlujitao4879b372018-12-03 18:45:47 +08002264 /**
2265 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2266 * so there's no need to preserve footer.
2267 */
2268 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2269 Crypto_Key_Location != "footer") {
2270 NeedPreserveFooter = false;
2271 }
2272
2273 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2274 if (!dev_sz)
2275 return false;
2276
2277 if (NeedPreserveFooter)
2278 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2279
Dees Troy9a4d7402019-03-21 14:17:28 -04002280 char dout[16];
2281 sprintf(dout, "%llu", dev_sz / 4096);
2282
2283 //string size_str =to_string(dev_sz / 4096);
2284 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002285 string Command;
2286
2287 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2288
2289 // Execute mke2fs to create empty ext4 filesystem
2290 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2291 LOGINFO("mke2fs command: %s\n", Command.c_str());
2292 ret = TWFunc::Exec_Cmd(Command);
2293 if (ret) {
2294 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2295 return false;
2296 }
2297
bigbiffad58e1b2020-07-06 20:24:34 -04002298 if (TWFunc::Path_Exists("/system/bin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002299 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2300 char *secontext = NULL;
2301 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2302 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2303 } else {
2304 // Execute e2fsdroid to initialize selinux context
bigbiff5b911ca2020-07-18 10:46:09 -04002305 if (Mount_Point == "/persist") {
2306 Mount(true);
2307 TWFunc::removeDir("/persist/lost+found", false);
2308 UnMount(true);
2309 }
dianlujitao3cf05a52019-05-15 15:33:27 +08002310 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2311 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2312 ret = TWFunc::Exec_Cmd(Command);
2313 if (ret) {
2314 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2315 return false;
2316 }
dianlujitao4879b372018-12-03 18:45:47 +08002317 }
2318 } else {
2319 LOGINFO("e2fsdroid not present\n");
2320 }
2321
2322 if (NeedPreserveFooter)
2323 Wipe_Crypto_Key();
2324 Current_File_System = File_System;
2325 Recreate_AndSec_Folder();
2326 gui_msg("done=Done.");
2327 return true;
2328}
2329
2330bool TWPartition::Wipe_EXT4() {
2331#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002332 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002333 bool NeedPreserveFooter = true;
2334
bigbiff7ba75002020-04-11 20:47:09 -04002335 if (!UnMount(true))
2336 return false;
2337
dianlujitao4879b372018-12-03 18:45:47 +08002338 Find_Actual_Block_Device();
2339 if (!Is_Present) {
2340 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2341 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2342 return false;
2343 }
dianlujitao4879b372018-12-03 18:45:47 +08002344
2345 /**
2346 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2347 * so there's no need to preserve footer.
2348 */
2349 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2350 Crypto_Key_Location != "footer") {
2351 NeedPreserveFooter = false;
2352 }
2353
2354 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2355 if (!dev_sz)
2356 return false;
2357
2358 if (NeedPreserveFooter)
2359 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2360
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002361 char *secontext = NULL;
2362
Greg Wallace4b44fef2015-12-29 15:33:24 -05002363 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002364
Dees Troy99c8dbf2014-03-10 16:53:58 +00002365 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002366 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002367 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002368 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002369 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002370 }
2371 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002372 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002373 return false;
2374 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002375 if (NeedPreserveFooter)
2376 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002377 string sedir = Mount_Point + "/lost+found";
2378 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2379 rmdir(sedir.c_str());
2380 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002381 return true;
2382 }
2383#else
dianlujitao4879b372018-12-03 18:45:47 +08002384 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002385#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002386}
2387
2388bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002389 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002390
bigbiff7ba75002020-04-11 20:47:09 -04002391 if (!UnMount(true))
2392 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002393
bigbiffad58e1b2020-07-06 20:24:34 -04002394 if (TWFunc::Path_Exists("/system/bin/mkfs.fat")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002395 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002396 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002397 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002398 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002399 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002400 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002401 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002402 return true;
2403 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002404 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002405 return false;
2406 }
2407 return true;
2408 }
2409 else
2410 return Wipe_RMRF();
2411
2412 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002413}
2414
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002415bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002416 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002417
bigbiff7ba75002020-04-11 20:47:09 -04002418 if (!UnMount(true))
2419 return false;
bigbiffad58e1b2020-07-06 20:24:34 -04002420 if (TWFunc::Path_Exists("/system/bin/mkexfatfs")) {
Greg Wallace4b44fef2015-12-29 15:33:24 -05002421 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002422 Find_Actual_Block_Device();
2423 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002424 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002425 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002426 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002427 return true;
2428 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002429 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002430 return false;
2431 }
2432 return true;
2433 }
2434 return false;
2435}
2436
Dees_Troy38bd7602012-09-14 13:33:53 -04002437bool TWPartition::Wipe_MTD() {
2438 if (!UnMount(true))
2439 return false;
2440
Greg Wallace4b44fef2015-12-29 15:33:24 -05002441 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002442
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002443 mtd_scan_partitions();
2444 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2445 if (mtd == NULL) {
2446 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2447 return false;
2448 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002449
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002450 MtdWriteContext* ctx = mtd_write_partition(mtd);
2451 if (ctx == NULL) {
2452 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2453 return false;
2454 }
2455 if (mtd_erase_blocks(ctx, -1) == -1) {
2456 mtd_write_close(ctx);
2457 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2458 return false;
2459 }
2460 if (mtd_write_close(ctx) != 0) {
2461 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2462 return false;
2463 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002464 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002465 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002466 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002467 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002468}
2469
2470bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002471 if (!Mount(true))
2472 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002473 // This is the only wipe that leaves the partition mounted, so we
2474 // must manually remove the partition from MTP if it is a storage
2475 // partition.
2476 if (Is_Storage)
2477 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002478
Ethan Yonker74db1572015-10-28 12:44:49 -05002479 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002480 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002481 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002482 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002483}
2484
Dees_Troye5017042013-08-29 16:38:55 +00002485bool TWPartition::Wipe_F2FS() {
systemaddb475c92021-08-12 20:33:20 +02002486 std::string f2fs_command;
Dees_Troye5017042013-08-29 16:38:55 +00002487
bigbiff7ba75002020-04-11 20:47:09 -04002488 if (!UnMount(true))
2489 return false;
dianlujitao4879b372018-12-03 18:45:47 +08002490
bigbiffad58e1b2020-07-06 20:24:34 -04002491 if (TWFunc::Path_Exists("/system/bin/mkfs.f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002492 f2fs_command = "/system/bin/mkfs.f2fs";
bigbiffad58e1b2020-07-06 20:24:34 -04002493 else if (TWFunc::Path_Exists("/system/bin/make_f2fs"))
systemaddb475c92021-08-12 20:33:20 +02002494 f2fs_command = "/system/bin/make_f2fs -g android";
bigbiff7ba75002020-04-11 20:47:09 -04002495 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002496 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002497 return Wipe_RMRF();
2498 }
bigbiff7ba75002020-04-11 20:47:09 -04002499
2500 bool NeedPreserveFooter = true;
systemaddb475c92021-08-12 20:33:20 +02002501 bool needs_casefold = false;
2502 bool needs_projid = false;
bigbiff7ba75002020-04-11 20:47:09 -04002503
2504 Find_Actual_Block_Device();
2505 if (!Is_Present) {
2506 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2507 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2508 return false;
2509 }
systemaddb475c92021-08-12 20:33:20 +02002510
2511 needs_casefold = android::base::GetBoolProperty("external_storage.casefold.enabled", false);
Captain Throwback88338682022-05-21 10:44:13 -04002512 needs_projid = android::base::GetBoolProperty("external_storage.projid.enabled", false);
bigbiff7ba75002020-04-11 20:47:09 -04002513 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2514 if (!dev_sz)
2515 return false;
2516
2517 if (NeedPreserveFooter)
2518 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
bigbiff7ba75002020-04-11 20:47:09 -04002519 char dev_sz_str[48];
2520 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
systemaddb475c92021-08-12 20:33:20 +02002521 if(needs_projid)
2522 f2fs_command += " -O project_quota,extra_attr";
2523
2524 if(needs_casefold)
2525 f2fs_command += " -O casefold -C utf8";
2526
Darth99fb13af2023-04-07 23:32:45 +01002527 if (Needs_Fs_Compress)
2528 f2fs_command += " -O compression,extra_attr";
2529
systemaddb475c92021-08-12 20:33:20 +02002530 f2fs_command += " " + Actual_Block_Device + " " + dev_sz_str;
2531
Captain Throwback88338682022-05-21 10:44:13 -04002532 if (TWFunc::Path_Exists("/system/bin/sload_f2fs")) {
2533 f2fs_command += " && sload_f2fs -t /data " + Actual_Block_Device;
bigbiff7ba75002020-04-11 20:47:09 -04002534 }
2535
2536 /**
2537 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2538 * so there's no need to preserve footer.
2539 */
2540 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2541 Crypto_Key_Location != "footer") {
2542 NeedPreserveFooter = false;
2543 }
systemaddb475c92021-08-12 20:33:20 +02002544 LOGINFO("mkfs.f2fs command: %s\n", f2fs_command.c_str());
2545 if (TWFunc::Exec_Cmd(f2fs_command) == 0) {
bigbiff7ba75002020-04-11 20:47:09 -04002546 if (NeedPreserveFooter)
2547 Wipe_Crypto_Key();
2548 Recreate_AndSec_Folder();
2549 gui_msg("done=Done.");
2550 return true;
2551 } else {
2552 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2553 return false;
2554 }
2555 return true;
Dees_Troye5017042013-08-29 16:38:55 +00002556}
2557
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002558bool TWPartition::Wipe_NTFS() {
2559 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002560 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002561
bigbiff7ba75002020-04-11 20:47:09 -04002562 if (!UnMount(true))
2563 return false;
2564
bigbiffad58e1b2020-07-06 20:24:34 -04002565 if (TWFunc::Path_Exists("/system/bin/mkntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002566 Ntfsmake_Binary = "mkntfs";
bigbiffad58e1b2020-07-06 20:24:34 -04002567 else if (TWFunc::Path_Exists("/system/bin/mkfs.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002568 Ntfsmake_Binary = "mkfs.ntfs";
2569 else
2570 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002571
Greg Wallace4b44fef2015-12-29 15:33:24 -05002572 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002573 Find_Actual_Block_Device();
bigbiffad58e1b2020-07-06 20:24:34 -04002574 command = "/system/bin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002575 if (TWFunc::Exec_Cmd(command) == 0) {
2576 Recreate_AndSec_Folder();
2577 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002578 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002579 } else {
2580 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2581 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002582 }
2583 return false;
2584}
2585
Dees_Troy51a0e822012-09-05 15:24:24 -04002586bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002587#ifdef TW_OEM_BUILD
2588 // In an OEM Build we want to do a full format
2589 return Wipe_Encryption();
2590#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002591 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002592
Dees_Troy38bd7602012-09-14 13:33:53 -04002593 if (!Mount(true))
2594 return false;
2595
Ethan Yonker74db1572015-10-28 12:44:49 -05002596 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002597 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2598 if (ret)
2599 gui_msg("done=Done.");
2600 return ret;
2601#endif // ifdef TW_OEM_BUILD
2602}
2603
2604bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2605 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002606
2607 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002608 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002609 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002610 struct dirent* de;
2611 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002612 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002613
Ethan Yonker66a19492015-12-10 10:19:45 -06002614 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002615 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002616 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002617 LOGINFO("skipped '%s'\n", dir.c_str());
2618 continue;
2619 }
Dees_Troyce675462013-01-09 19:48:21 +00002620 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002621 dir.append("/");
2622 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2623 closedir(d);
2624 return false;
2625 }
2626 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002627 } 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 +03002628 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002629 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002630 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002631 }
2632 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002633
Dees_Troy16b74352012-11-14 22:27:31 +00002634 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002635 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002636 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002637 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002638}
2639
dianlujitao4879b372018-12-03 18:45:47 +08002640void TWPartition::Wipe_Crypto_Key() {
2641 Find_Actual_Block_Device();
2642 if (Crypto_Key_Location.empty())
2643 return;
2644 else if (Crypto_Key_Location == "footer") {
2645 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2646 if (fd < 0) {
2647 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2648 return;
2649 }
2650
2651 unsigned int block_count;
2652 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2653 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2654 } else {
2655 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2656 off64_t offset = ((off64_t)block_count * 512) - newlen;
2657 if (lseek64(fd, offset, SEEK_SET) == -1) {
2658 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2659 } else {
2660 void* buffer = malloc(newlen);
2661 if (!buffer) {
2662 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2663 } else {
2664 memset(buffer, 0, newlen);
2665 int ret = write(fd, buffer, newlen);
2666 if (ret != newlen) {
2667 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2668 } else {
2669 LOGINFO("Successfully wiped crypto footer.\n");
2670 }
2671 free(buffer);
2672 }
2673 }
2674 }
2675 close(fd);
2676 } else {
2677 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2678 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2679 TWFunc::Exec_Cmd(Command);
2680 } else {
2681 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2682 }
2683 }
2684}
2685
bigbiffce8f83c2015-12-12 18:30:21 -05002686bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002687 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002688 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002689
Dees_Troy43d8b002012-09-17 16:00:01 -04002690 if (!Mount(true))
2691 return false;
2692
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002693 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002694 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002695
Ethan Yonker472f5062016-02-25 13:47:30 -06002696 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002697
Dees_Troy83bd4832013-05-04 12:39:56 +00002698#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002699 if (Can_Encrypt_Backup) {
2700 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2701 if (tar.use_encryption) {
2702 if (Use_Userdata_Encryption)
2703 tar.userdata_encryption = tar.use_encryption;
2704 string Password;
2705 DataManager::GetValue("tw_backup_password", Password);
2706 tar.setpassword(Password);
2707 } else {
2708 tar.use_encryption = 0;
2709 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002710 }
2711#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002712
Ethan Yonker472f5062016-02-25 13:47:30 -06002713 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002714 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002715 if (Has_Data_Media)
2716 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 -04002717 if (Mount_Point == "/data" && DataManager::GetIntValue(TW_IS_FBE)) {
2718 std::vector<users_struct>::iterator iter;
2719 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
2720 for (iter = userList->begin(); iter != userList->end(); iter++) {
2721 if (!(*iter).isDecrypted && (*iter).userId != "0") {
2722 gui_msg(Msg(msg::kWarning,
2723 "backup_storage_undecrypt_warning=Backup will not include some files from user {1} "
2724 "because the user is not decrypted.")((*iter).userId));
2725 backup_exclusions.add_absolute_dir("/data/system_ce/" + (*iter).userId);
2726 backup_exclusions.add_absolute_dir("/data/misc_ce/" + (*iter).userId);
2727 backup_exclusions.add_absolute_dir("/data/vendor_ce/" + (*iter).userId);
2728 backup_exclusions.add_absolute_dir("/data/media/" + (*iter).userId);
2729 backup_exclusions.add_absolute_dir("/data/user/" + (*iter).userId);
2730 }
2731 }
2732 }
bigbiffce8f83c2015-12-12 18:30:21 -05002733 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002734 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002735 tar.setdir(Backup_Path);
2736 tar.setfn(Full_FileName);
2737 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002738 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002739 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002740 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002741 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002742 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002743}
2744
bigbiffce8f83c2015-12-12 18:30:21 -05002745bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2746 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002747
Ethan Yonker74db1572015-10-28 12:44:49 -05002748 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2749 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002750
Ethan Yonker472f5062016-02-25 13:47:30 -06002751 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002752
bigbiffce8f83c2015-12-12 18:30:21 -05002753 if (part_settings->adbbackup) {
2754 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002755 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002756 }
2757 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002758 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002759
2760 part_settings->total_restore_size = Backup_Size;
2761
2762 if (part_settings->adbbackup) {
2763 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2764 return false;
2765 }
2766
2767 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002768 return false;
2769
bigbiffce8f83c2015-12-12 18:30:21 -05002770 if (part_settings->adbbackup) {
2771 if (!twadbbu::Write_TWEOF())
2772 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002773 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002774 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002775}
2776
bigbiffce8f83c2015-12-12 18:30:21 -05002777bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2778 unsigned long long RW_Block_Size, Remain = Backup_Size;
2779 int src_fd = -1, dest_fd = -1;
2780 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002781 bool ret = false;
2782 void* buffer = NULL;
2783 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002784 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002785
bigbiffce8f83c2015-12-12 18:30:21 -05002786 if (part_settings->PM_Method == PM_BACKUP) {
2787 srcfn = Actual_Block_Device;
2788 if (part_settings->adbbackup)
2789 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002790 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002791 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002792 }
bigbiffce8f83c2015-12-12 18:30:21 -05002793 }
2794 else {
me-cafebabe76693202022-07-29 06:12:38 +08002795#ifdef TW_ENABLE_BLKDISCARD
2796 BlkDiscard();
2797#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002798 destfn = Actual_Block_Device;
2799 if (part_settings->adbbackup) {
2800 srcfn = TW_ADB_RESTORE;
2801 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002802 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002803 Remain = TWFunc::Get_File_Size(srcfn);
2804 }
2805 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002806
bigbiffce8f83c2015-12-12 18:30:21 -05002807 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002808 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002809 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002810 return false;
2811 }
bigbiffce8f83c2015-12-12 18:30:21 -05002812
2813 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 -06002814 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002815 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002816 goto exit;
2817 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002818
bigbiffce8f83c2015-12-12 18:30:21 -05002819 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2820
2821 if (part_settings->adbbackup) {
2822 RW_Block_Size = MAX_ADB_READ;
2823 bs = MAX_ADB_READ;
2824 }
2825 else {
2826 RW_Block_Size = 1048576LLU; // 1MB
2827 bs = (ssize_t)(RW_Block_Size);
2828 }
2829
Ethan Yonker472f5062016-02-25 13:47:30 -06002830 buffer = malloc((size_t)bs);
2831 if (!buffer) {
2832 LOGINFO("Raw_Read_Write failed to malloc\n");
2833 goto exit;
2834 }
bigbiffce8f83c2015-12-12 18:30:21 -05002835
2836 if (part_settings->progress)
2837 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2838
Ethan Yonker472f5062016-02-25 13:47:30 -06002839 while (Remain > 0) {
2840 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002841 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002842 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002843 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2844 goto exit;
2845 }
2846 if (write(dest_fd, buffer, bs) != bs) {
2847 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2848 goto exit;
2849 }
2850 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002851 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002852 if (part_settings->progress)
2853 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002854 if (PartitionManager.Check_Backup_Cancel() != 0)
2855 goto exit;
2856 }
bigbiffce8f83c2015-12-12 18:30:21 -05002857 if (part_settings->progress)
2858 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002859 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002860
2861 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2862 tw_set_default_metadata(destfn.c_str());
2863 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2864 }
2865
Ethan Yonker472f5062016-02-25 13:47:30 -06002866 ret = true;
2867exit:
2868 if (src_fd >= 0)
2869 close(src_fd);
2870 if (dest_fd >= 0)
2871 close(dest_fd);
2872 if (buffer)
2873 free(buffer);
2874 return ret;
2875}
2876
bigbiffce8f83c2015-12-12 18:30:21 -05002877bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002878 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002879
Ethan Yonker74db1572015-10-28 12:44:49 -05002880 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2881 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002882
bigbiffce8f83c2015-12-12 18:30:21 -05002883 if (part_settings->progress)
2884 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002885
Ethan Yonker472f5062016-02-25 13:47:30 -06002886 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002887 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002888
2889 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002890
Dees_Troy2673cec2013-04-02 20:22:16 +00002891 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002892 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002893 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002894 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2895 // 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 -06002896 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002897 return false;
2898 }
bigbiffce8f83c2015-12-12 18:30:21 -05002899 if (part_settings->progress)
2900 part_settings->progress->UpdateSize(Backup_Size);
2901
Dees_Troy43d8b002012-09-17 16:00:01 -04002902 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002903}
2904
bigbiffce8f83c2015-12-12 18:30:21 -05002905unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2906 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002907 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002908 if (restore_info.LoadValues() == 0) {
2909 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2910 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2911 return Restore_Size;
2912 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002913 }
2914 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002915
Matt Mower029a82d2017-01-08 13:12:38 -06002916 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2917 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002918
2919 if (Is_Image(Restore_File_System)) {
2920 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2921 return Restore_Size;
2922 }
2923
2924 twrpTar tar;
2925 tar.setdir(Backup_Path);
2926 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002927 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002928#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2929 string Password;
2930 DataManager::GetValue("tw_restore_password", Password);
2931 if (!Password.empty())
2932 tar.setpassword(Password);
2933#endif
2934 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002935 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002936 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002937 Restore_Size = tar.get_size();
2938 return Restore_Size;
2939}
2940
bigbiffce8f83c2015-12-12 18:30:21 -05002941bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002942 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002943 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002944 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002945
Dees_Troye58d5262012-09-21 12:27:57 -04002946 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002947 if (!Wipe_AndSec())
2948 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002949 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002950 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002951 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002952 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 -05002953 if (!Wipe_Data_Without_Wiping_Media())
2954 return false;
2955 } else {
2956 if (!Wipe(Restore_File_System))
2957 return false;
2958 }
Dees_Troye58d5262012-09-21 12:27:57 -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));
Dees_Troy43d8b002012-09-17 16:00:01 -04002962
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002963 // Remount as read/write as needed so we can restore the backup
2964 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002965 return false;
2966
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002967 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002968 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002969 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002970 tar.setdir(Backup_Path);
2971 tar.setfn(Full_FileName);
2972 tar.backup_name = Backup_Name;
2973#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2974 string Password;
2975 DataManager::GetValue("tw_restore_password", Password);
2976 if (!Password.empty())
2977 tar.setpassword(Password);
2978#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002979 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2980 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002981 ret = false;
2982 else
2983 ret = true;
2984#ifdef HAVE_CAPABILITIES
2985 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002986 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002987 struct vfs_cap_data cap_data;
2988 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2989
2990 memset(&cap_data, 0, sizeof(cap_data));
2991 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2992 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2993 cap_data.data[0].inheritable = 0;
2994 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2995 cap_data.data[1].inheritable = 0;
2996 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2997 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2998 } else {
2999 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
3000 }
3001 }
3002#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05003003 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
3004 // Remount as read only when restoration is complete
3005 ReMount(true);
3006
Dees Troy4159aed2014-02-28 17:24:43 +00003007 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04003008}
3009
bigbiffce8f83c2015-12-12 18:30:21 -05003010bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003011 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05003012 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04003013
Matt Mower3c366972015-12-25 19:28:31 -06003014 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05003015 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05003016
3017 if (part_settings->adbbackup)
3018 Full_FileName = TW_ADB_RESTORE;
3019 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003020 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08003021
Ethan Yonker96af84a2015-01-05 14:58:36 -06003022 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05003023 if (!part_settings->adbbackup)
3024 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
3025 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06003026 return false;
3027 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05003028 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
3029 return false;
3030 }
3031
3032 if (part_settings->adbbackup) {
3033 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06003034 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08003035 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003036 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04003037}
Dees_Troy5bf43922012-09-07 16:07:55 -04003038
3039bool TWPartition::Update_Size(bool Display_Error) {
me-cafebabeb52a4812022-07-28 03:45:22 +08003040 bool ret = false, Was_Already_Mounted = false, ro = false;
Dees_Troy51127312012-09-08 13:08:49 -04003041
Ethan Yonker1b190162016-12-05 15:25:19 -06003042 Find_Actual_Block_Device();
3043
bigbiffee7b7ff2020-03-23 15:08:27 -04003044 if (Actual_Block_Device.empty())
3045 return false;
3046
me-cafebabeb52a4812022-07-28 03:45:22 +08003047 ro = Mount_Read_Only;
3048 Mount_Read_Only = true;
3049
Ethan Yonker1b190162016-12-05 15:25:19 -06003050 if (!Can_Be_Mounted && !Is_Encrypted) {
3051 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
3052 Used = Size;
3053 Backup_Size = Size;
me-cafebabeb52a4812022-07-28 03:45:22 +08003054 goto success;
Ethan Yonker1b190162016-12-05 15:25:19 -06003055 }
me-cafebabeb52a4812022-07-28 03:45:22 +08003056 goto fail;
Ethan Yonker1b190162016-12-05 15:25:19 -06003057 }
Dees_Troy5bf43922012-09-07 16:07:55 -04003058
Dees_Troy0550cfb2012-10-13 11:56:13 -04003059 Was_Already_Mounted = Is_Mounted();
bigbiffee7b7ff2020-03-23 15:08:27 -04003060
Dees_Troy38bd7602012-09-14 13:33:53 -04003061 if (Removable || Is_Encrypted) {
3062 if (!Mount(false))
me-cafebabeb52a4812022-07-28 03:45:22 +08003063 goto success;
Dees_Troy38bd7602012-09-14 13:33:53 -04003064 } else if (!Mount(Display_Error))
me-cafebabeb52a4812022-07-28 03:45:22 +08003065 goto fail;
Dees_Troy51127312012-09-08 13:08:49 -04003066
3067 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003068 if (!ret || Size == 0) {
3069 if (!Get_Size_Via_df(Display_Error)) {
3070 if (!Was_Already_Mounted)
3071 UnMount(false);
me-cafebabeb52a4812022-07-28 03:45:22 +08003072 goto fail;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003073 }
3074 }
Dees_Troy51127312012-09-08 13:08:49 -04003075
Dees_Troy5bf43922012-09-07 16:07:55 -04003076 if (Has_Data_Media) {
3077 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003078 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003079 Backup_Size = Used;
3080 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04003081 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05003082 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003083 } else {
3084 if (!Was_Already_Mounted)
3085 UnMount(false);
me-cafebabeb52a4812022-07-28 03:45:22 +08003086 goto fail;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003087 }
Dees_Troye58d5262012-09-21 12:27:57 -04003088 } else if (Has_Android_Secure) {
3089 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06003090 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04003091 else {
3092 if (!Was_Already_Mounted)
3093 UnMount(false);
me-cafebabeb52a4812022-07-28 03:45:22 +08003094 goto fail;
Dees_Troy0550cfb2012-10-13 11:56:13 -04003095 }
Dees_Troy5bf43922012-09-07 16:07:55 -04003096 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04003097 if (!Was_Already_Mounted)
3098 UnMount(false);
me-cafebabeb52a4812022-07-28 03:45:22 +08003099success:
3100 Mount_Read_Only = ro;
Dees_Troy5bf43922012-09-07 16:07:55 -04003101 return true;
me-cafebabeb52a4812022-07-28 03:45:22 +08003102fail:
3103 Mount_Read_Only = ro;
3104 return false;
Dees_Troy51127312012-09-08 13:08:49 -04003105}
Dees_Troy38bd7602012-09-14 13:33:53 -04003106
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003107bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
3108 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
3109 string Path = TWFunc::Get_Path(Device);
3110 string Dev = TWFunc::Get_Filename(Device);
3111 size_t wildcard_index = Dev.find("*");
3112 if (wildcard_index != string::npos)
3113 Dev = Dev.substr(0, wildcard_index);
3114 wildcard_index = Dev.size();
3115 DIR* d = opendir(Path.c_str());
3116 if (d == NULL) {
3117 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
3118 return false;
3119 }
3120 struct dirent* de;
3121 while ((de = readdir(d)) != NULL) {
3122 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
3123 continue;
3124
3125 string item = Path + "/";
3126 item.append(de->d_name);
3127 if (PartitionManager.Find_Partition_By_Block_Device(item))
3128 continue;
3129 TWPartition *part = new TWPartition;
3130 char buffer[MAX_FSTAB_LINE_LENGTH];
3131 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
bigbiff8da46fa2020-09-08 16:42:34 -04003132 part->Process_Fstab_Line(buffer, false, NULL);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003133 char display[MAX_FSTAB_LINE_LENGTH];
3134 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
3135 part->Storage_Name = display;
3136 part->Display_Name = display;
3137 part->Primary_Block_Device = item;
3138 part->Wildcard_Block_Device = false;
3139 part->Is_SubPartition = true;
3140 part->SubPartition_Of = Mount_Point;
3141 part->Is_Storage = Is_Storage;
3142 part->Can_Be_Mounted = true;
3143 part->Removable = true;
3144 part->Can_Be_Wiped = Can_Be_Wiped;
3145 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
3146 part->Find_Actual_Block_Device();
3147 part->Update_Size(false);
3148 Has_SubPartition = true;
3149 PartitionManager.Output_Partition(part);
3150 PartitionManager.Add_Partition(part);
3151 }
3152 closedir(d);
3153 return (mount_point_index > 0);
3154}
3155
Dees_Troy38bd7602012-09-14 13:33:53 -04003156void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06003157 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
3158 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
3159 * If we have a syfs entry then we are looking for this device from a uevent add.
3160 * The uevent add will set the primary block device based on the data we receive from
3161 * after checking for adopted storage. If the device ends up being adopted, then the
3162 * decrypted block device will be set instead of the primary block device. */
3163 Is_Present = false;
3164 return;
3165 }
3166 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
3167 Is_Present = false;
3168 Actual_Block_Device = "";
3169 Can_Be_Mounted = false;
3170 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
3171 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
3172 if (TWFunc::Path_Exists(Dev)) {
3173 Is_Present = true;
3174 Can_Be_Mounted = true;
3175 Actual_Block_Device = Dev;
3176 }
3177 }
3178 return;
3179 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003180 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06003181 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003182 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06003183 return;
3184 }
3185 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
3186 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
3187 unlink(Primary_Block_Device.c_str());
3188 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
3189 Is_Present = true;
3190 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04003191 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04003192 Is_Present = true;
3193 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003194 return;
3195 }
Ethan Yonker1b190162016-12-05 15:25:19 -06003196 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04003197 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04003198 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003199 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04003200 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003201 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003202}
3203
3204void TWPartition::Recreate_Media_Folder(void) {
3205 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06003206 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04003207
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06003208 if (Is_FBE) {
3209 LOGINFO("Not recreating media folder on FBE\n");
3210 return;
3211 }
Dees_Troy38bd7602012-09-14 13:33:53 -04003212 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003213 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
3214 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003215 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06003216 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
3217 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08003218 string Internal_path = DataManager::GetStrValue("tw_internal_path");
3219 if (!Internal_path.empty()) {
3220 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
3221 mkdir(Internal_path.c_str(), 0770);
3222 }
3223#ifdef TW_INTERNAL_STORAGE_PATH
3224 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
3225#endif
Matt Mower87413642017-01-17 21:14:46 -06003226
thata3d31fb2014-12-21 22:27:40 +01003227 // Afterwards, we will try to set the
3228 // default metadata that we were hopefully able to get during
3229 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06003230 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08003231 if (!Internal_path.empty())
3232 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06003233
Ethan Yonker5eac2222014-06-11 12:22:55 -05003234 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003235 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003236 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003237 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003238}
Dees_Troye58d5262012-09-21 12:27:57 -04003239
3240void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003241 if (!Has_Android_Secure)
3242 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003243 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003244 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003245 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003246 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003247 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003248 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003249 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003250 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003251 }
3252}
bigbiff7cb4c332014-11-26 20:36:07 -05003253
3254uint64_t TWPartition::Get_Max_FileSize() {
3255 uint64_t maxFileSize = 0;
3256 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3257 const uint64_t constTB = (uint64_t) constGB * 1024;
3258 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003259 if (Current_File_System == "ext4")
3260 maxFileSize = 16 * constTB; //16 TB
3261 else if (Current_File_System == "vfat")
3262 maxFileSize = 4 * constGB; //4 GB
Captain Throwback47bf7202020-10-06 17:39:39 -04003263 else if (Current_File_System == "ntfs" || Current_File_System == "tntfs")
bigbiff0c532032014-12-21 13:41:26 -05003264 maxFileSize = 256 * constTB; //256 TB
3265 else if (Current_File_System == "exfat")
3266 maxFileSize = 16 * constPB; //16 PB
3267 else if (Current_File_System == "ext3")
3268 maxFileSize = 2 * constTB; //2 TB
3269 else if (Current_File_System == "f2fs")
3270 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003271 else
3272 maxFileSize = 100000000L;
3273 return maxFileSize - 1;
3274}
3275
bigbiffce8f83c2015-12-12 18:30:21 -05003276bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3277 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003278
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003279 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003280
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003281 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003282
3283 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003284 LOGERR("Cannot flash images to file systems\n");
3285 return false;
3286 } else if (!Can_Flash_Img) {
3287 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3288 return false;
3289 } else {
3290 if (!Find_Partition_Size()) {
3291 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3292 return false;
3293 }
bigbiffce8f83c2015-12-12 18:30:21 -05003294 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003295 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003296 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003297 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003298 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003299 return false;
3300 }
bigbiffce8f83c2015-12-12 18:30:21 -05003301 if (Backup_Method == BM_DD) {
3302 if (!part_settings->adbbackup) {
3303 if (Is_Sparse_Image(full_filename)) {
3304 return Flash_Sparse_Image(full_filename);
3305 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003306 }
bigbiffce8f83c2015-12-12 18:30:21 -05003307 return Raw_Read_Write(part_settings);
3308 } else if (Backup_Method == BM_FLASH_UTILS) {
3309 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003310 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003311 }
3312
3313 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3314 return false;
3315}
3316
Ethan Yonker472f5062016-02-25 13:47:30 -06003317bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003318 uint32_t magic = 0;
3319 int fd = open(Filename.c_str(), O_RDONLY);
3320 if (fd < 0) {
3321 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3322 return false;
3323 }
bigbiffce8f83c2015-12-12 18:30:21 -05003324
HashBanged974bb2016-01-30 14:20:09 -05003325 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3326 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3327 close(fd);
3328 return false;
3329 }
3330 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003331 if (magic == SPARSE_HEADER_MAGIC)
3332 return true;
3333 return false;
3334}
3335
3336bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3337 string Command;
3338
me-cafebabe76693202022-07-29 06:12:38 +08003339#ifdef TW_ENABLE_BLKDISCARD
3340 BlkDiscard();
3341#endif
3342
Ethan Yonker472f5062016-02-25 13:47:30 -06003343 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3344
3345 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003346 LOGINFO("Flash command: '%s'\n", Command.c_str());
3347 TWFunc::Exec_Cmd(Command);
3348 return true;
3349}
3350
Ethan Yonker472f5062016-02-25 13:47:30 -06003351bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003352 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003353 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003354
Ethan Yonker74db1572015-10-28 12:44:49 -05003355 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003356 if (progress) {
3357 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3358 progress->SetPartitionSize(file_size);
3359 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003360 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3361 Command = "erase_image " + MTD_Name;
3362 LOGINFO("Erase command: '%s'\n", Command.c_str());
3363 TWFunc::Exec_Cmd(Command);
3364 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3365 LOGINFO("Flash command: '%s'\n", Command.c_str());
3366 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003367 if (progress)
3368 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003369 return true;
3370}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003371
3372void TWPartition::Change_Mount_Read_Only(bool new_value) {
3373 Mount_Read_Only = new_value;
3374}
3375
bigbiffce8f83c2015-12-12 18:30:21 -05003376bool TWPartition::Is_Read_Only() {
3377 return Mount_Read_Only;
3378}
3379
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003380int TWPartition::Check_Lifetime_Writes() {
3381 bool original_read_only = Mount_Read_Only;
3382 int ret = 1;
3383
3384 Mount_Read_Only = true;
3385 if (Mount(false)) {
3386 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003387 string temp = Actual_Block_Device;
3388 Find_Real_Block_Device(temp, false);
3389 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003390 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3391 string result;
3392 if (TWFunc::Path_Exists(file)) {
3393 if (TWFunc::read_file(file, result) != 0) {
3394 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3395 } else {
3396 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3397 if (result == "0") {
3398 ret = 0;
3399 }
3400 }
3401 } else {
3402 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3403 }
3404 UnMount(true);
3405 } else {
3406 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3407 }
3408 Mount_Read_Only = original_read_only;
3409 return ret;
3410}
Ethan Yonker66a19492015-12-10 10:19:45 -06003411
3412int TWPartition::Decrypt_Adopted() {
3413#ifdef TW_INCLUDE_CRYPTO
3414 int ret = 1;
3415 Is_Adopted_Storage = false;
3416 string Adopted_Key_File = "";
3417
3418 if (!Removable)
3419 return ret;
3420
3421 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3422 if (fd < 0) {
3423 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3424 return ret;
3425 }
3426 char type_guid[80];
3427 char part_guid[80];
3428
nkk717aa6fc62017-03-24 18:28:03 +02003429 uint32_t p_num;
3430 size_t last_digit = Primary_Block_Device.find_last_not_of("0123456789");
3431 if ((last_digit != string::npos) && (last_digit != Primary_Block_Device.length()-1))
3432 p_num = atoi(Primary_Block_Device.substr(last_digit + 1).c_str()) + 1;
3433 else
3434 p_num = 2;
3435
3436 if (gpt_disk_get_partition_info(fd, p_num, type_guid, part_guid) == 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003437 LOGINFO("type: '%s'\n", type_guid);
3438 LOGINFO("part: '%s'\n", part_guid);
3439 Adopted_GUID = part_guid;
3440 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3441 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3442 LOGINFO("android_expand found\n");
3443 Adopted_Key_File = "/data/misc/vold/expand_";
3444 Adopted_Key_File += part_guid;
3445 Adopted_Key_File += ".key";
3446 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3447 Is_Adopted_Storage = true;
3448 /* Until we find a use case for this, I think it is safe
3449 * to disable USB Mass Storage whenever adopted storage
3450 * is present.
3451 */
nkk717aa6fc62017-03-24 18:28:03 +02003452 if (p_num == 2) {
3453 // TODO: Properly detect mixed vs fully adopted storage. Maybe this
3454 // should be moved to partitionmanager instead, and disable after
3455 // checking all partitions. Also the presence of adopted storage does
3456 // not necessarily mean it's being used as Internal Storage
3457 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3458 DataManager::SetValue("tw_has_usb_storage", 0);
3459 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003460 }
3461 }
3462 }
3463
3464 if (Is_Adopted_Storage) {
nkk717aa6fc62017-03-24 18:28:03 +02003465 string Adopted_Block_Device = Alternate_Block_Device + "p" + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003466 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
nkk717aa6fc62017-03-24 18:28:03 +02003467 Adopted_Block_Device = Alternate_Block_Device + TWFunc::to_string(p_num);
Ethan Yonker66a19492015-12-10 10:19:45 -06003468 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3469 LOGINFO("Adopted block device does not exist\n");
3470 goto exit;
3471 }
3472 }
3473 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3474 char crypto_blkdev[MAXPATHLEN];
3475 std::string thekey;
3476 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3477 if (fdkey < 0) {
3478 LOGINFO("failed to open key file\n");
3479 goto exit;
3480 }
3481 char buf[512];
3482 ssize_t n;
3483 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3484 thekey.append(buf, n);
3485 }
3486 close(fdkey);
bigbiffdf53b6c2022-01-17 19:31:52 -05003487 // unsigned char* key = (unsigned char*) thekey.data();
3488 // cryptfs_revert_ext_volume(part_guid);
Ethan Yonker66a19492015-12-10 10:19:45 -06003489
bigbiffdf53b6c2022-01-17 19:31:52 -05003490 // ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
Ethan Yonker66a19492015-12-10 10:19:45 -06003491 if (ret == 0) {
3492 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3493 Decrypted_Block_Device = crypto_blkdev;
3494 Is_Decrypted = true;
3495 Is_Encrypted = true;
3496 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003497 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003498 LOGERR("Failed to mount decrypted adopted storage device\n");
3499 Is_Decrypted = false;
3500 Is_Encrypted = false;
bigbiffdf53b6c2022-01-17 19:31:52 -05003501 // cryptfs_revert_ext_volume(part_guid);
Ethan Yonker66a19492015-12-10 10:19:45 -06003502 ret = 1;
3503 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003504 UnMount(false);
3505 Has_Android_Secure = false;
3506 Symlink_Path = "";
3507 Symlink_Mount_Point = "";
3508 Backup_Name = Mount_Point.substr(1);
3509 Backup_Path = Mount_Point;
3510 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3511 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3512 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3513 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3514 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003515 Setup_Data_Media();
Ethan Yonker66a19492015-12-10 10:19:45 -06003516 Wipe_Available_in_GUI = true;
3517 Wipe_During_Factory_Reset = true;
3518 Can_Be_Backed_Up = true;
3519 Can_Encrypt_Backup = true;
3520 Use_Userdata_Encryption = true;
3521 Is_Storage = true;
3522 Storage_Name = "Adopted Storage";
3523 Is_SubPartition = true;
3524 SubPartition_Of = "/data";
3525 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3526 DataManager::SetValue("tw_has_adopted_storage", 1);
3527 }
3528 } else {
3529 LOGERR("Failed to setup adopted storage decryption\n");
3530 }
3531 }
3532exit:
Matt Mower06543e32017-01-06 15:25:26 -06003533 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003534 return ret;
3535#else
3536 LOGINFO("Decrypt_Adopted: no crypto support\n");
3537 return 1;
3538#endif
3539}
3540
3541void TWPartition::Revert_Adopted() {
3542#ifdef TW_INCLUDE_CRYPTO
3543 if (!Adopted_GUID.empty()) {
3544 PartitionManager.Remove_MTP_Storage(Mount_Point);
3545 UnMount(false);
bigbiffdf53b6c2022-01-17 19:31:52 -05003546 // cryptfs_revert_ext_volume(Adopted_GUID.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06003547 Is_Adopted_Storage = false;
3548 Is_Encrypted = false;
3549 Is_Decrypted = false;
3550 Decrypted_Block_Device = "";
3551 Find_Actual_Block_Device();
3552 Wipe_During_Factory_Reset = false;
3553 Can_Be_Backed_Up = false;
3554 Can_Encrypt_Backup = false;
3555 Use_Userdata_Encryption = false;
3556 Is_SubPartition = false;
3557 SubPartition_Of = "";
3558 Has_Data_Media = false;
3559 Storage_Path = Mount_Point;
3560 if (!Symlink_Mount_Point.empty()) {
3561 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3562 if (Dat) {
3563 Dat->UnMount(false);
3564 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3565 }
3566 Symlink_Mount_Point = "";
3567 }
3568 }
3569#else
3570 LOGINFO("Revert_Adopted: no crypto support\n");
3571#endif
3572}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003573
3574void TWPartition::Set_Backup_FileName(string fname) {
3575 Backup_FileName = fname;
3576}
3577
3578string TWPartition::Get_Backup_Name() {
3579 return Backup_Name;
3580}
bigbiffee7b7ff2020-03-23 15:08:27 -04003581
3582string TWPartition::Get_Mount_Point() {
3583 return Mount_Point;
3584}
3585
3586void TWPartition::Set_Block_Device(std::string block_device) {
3587 Primary_Block_Device = Actual_Block_Device = block_device;
3588}
3589
3590bool TWPartition::Get_Super_Status() {
3591 return Is_Super;
3592}
3593
3594void TWPartition::Set_Can_Be_Backed_Up(bool val) {
3595 Can_Be_Backed_Up = val;
3596}
3597
3598void TWPartition::Set_Can_Be_Wiped(bool val) {
3599 Can_Be_Wiped = val;
3600 Wipe_Available_in_GUI = val;
bigbiffad58e1b2020-07-06 20:24:34 -04003601}
3602
3603std::string TWPartition::Get_Backup_FileName() {
3604 return Backup_FileName;
3605}
3606
3607std::string TWPartition::Get_Display_Name() {
3608 return Display_Name;
3609}
3610
3611bool TWPartition::Is_SlotSelect() {
3612 return SlotSelect;
Mohd Faraz815e2402020-09-19 19:31:52 +05303613}