blob: 99f4949ecc59aac96361488be0a37c4f58b2f29c [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>
Darth98c5088d2022-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
53 #include "crypto/fde/cryptfs.h"
bigbiffa957f072021-03-07 18:20:29 -050054 #include "Decrypt.h"
Ethan Yonker98661c12018-10-17 08:39:28 -050055#else
56 #define CRYPT_FOOTER_OFFSET 0x4000
57#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040058extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040059 #include "mtdutils/mtdutils.h"
60 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000061#ifdef USE_EXT4
Ethan Yonker8373cfe2017-09-08 06:50:54 -050062 // #include "make_ext4fs.h" TODO need ifdef for android8
63 #include <ext4_utils/make_ext4fs.h>
Dees_Troya95f55c2013-08-17 13:14:43 +000064#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060065#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker66a19492015-12-10 10:19:45 -060066 #include "gpt/gpt.h"
Ethan Yonker71413f42014-02-26 13:36:08 -060067#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040068}
Matt Mower87413642017-01-17 21:14:46 -060069#include <selinux/selinux.h>
Ethan Yonkerf27497f2014-02-09 11:48:33 -060070#include <selinux/label.h>
Dees Troy4159aed2014-02-28 17:24:43 +000071#ifdef HAVE_CAPABILITIES
72#include <sys/capability.h>
73#include <sys/xattr.h>
74#include <linux/xattr.h>
75#endif
HashBanged974bb2016-01-30 14:20:09 -050076#include <sparse_format.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060077#include "progresstracking.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040078
bigbiff bigbiff9c754052013-01-09 09:09:08 -050079using namespace std;
80
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060081static 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
82
Dees_Troya95f55c2013-08-17 13:14:43 +000083extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050084extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000085
Hashcode62bd9e02013-11-19 21:59:42 -080086struct flag_list {
87 const char *name;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060088 unsigned long flag;
Hashcode62bd9e02013-11-19 21:59:42 -080089};
90
Matt Mower4ab42b12016-04-21 13:52:18 -050091const struct flag_list mount_flags[] = {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060092 { "noatime", MS_NOATIME },
93 { "noexec", MS_NOEXEC },
94 { "nosuid", MS_NOSUID },
95 { "nodev", MS_NODEV },
96 { "nodiratime", MS_NODIRATIME },
97 { "ro", MS_RDONLY },
98 { "rw", 0 },
99 { "remount", MS_REMOUNT },
100 { "bind", MS_BIND },
101 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000102#ifdef MS_UNBINDABLE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600103 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000104#endif
105#ifdef MS_PRIVATE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600106 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000107#endif
108#ifdef MS_SLAVE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600109 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000110#endif
111#ifdef MS_SHARED
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600112 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000113#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600114 { "sync", MS_SYNCHRONOUS },
115 { 0, 0 },
116};
117
118const char *ignored_mount_items[] = {
119 "defaults=",
120 "errors=",
Ethan Yonker93382822018-11-01 15:25:31 -0500121 "latemount",
122 "sysfs_path=",
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600123 NULL
Hashcode62bd9e02013-11-19 21:59:42 -0800124};
125
Matt Mower2416a502016-04-12 19:54:46 -0500126enum TW_FSTAB_FLAGS {
127 TWFLAG_DEFAULTS, // Retain position
128 TWFLAG_ANDSEC,
129 TWFLAG_BACKUP,
130 TWFLAG_BACKUPNAME,
131 TWFLAG_BLOCKSIZE,
132 TWFLAG_CANBEWIPED,
133 TWFLAG_CANENCRYPTBACKUP,
134 TWFLAG_DISPLAY,
135 TWFLAG_ENCRYPTABLE,
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500136 TWFLAG_FILEENCRYPTION,
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500137 TWFLAG_METADATA_ENCRYPTION,
Matt Mower2416a502016-04-12 19:54:46 -0500138 TWFLAG_FLASHIMG,
139 TWFLAG_FORCEENCRYPT,
140 TWFLAG_FSFLAGS,
141 TWFLAG_IGNOREBLKID,
142 TWFLAG_LENGTH,
143 TWFLAG_MOUNTTODECRYPT,
Captain Throwbacke848afc2022-02-08 15:31:44 -0500144 TWFLAG_QUOTA,
Matt Mower2416a502016-04-12 19:54:46 -0500145 TWFLAG_REMOVABLE,
Matt Mower2416a502016-04-12 19:54:46 -0500146 TWFLAG_SETTINGSSTORAGE,
147 TWFLAG_STORAGE,
148 TWFLAG_STORAGENAME,
149 TWFLAG_SUBPARTITIONOF,
150 TWFLAG_SYMLINK,
151 TWFLAG_USERDATAENCRYPTBACKUP,
152 TWFLAG_USERMRF,
153 TWFLAG_WIPEDURINGFACTORYRESET,
154 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600155 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600156 TWFLAG_WAIT,
157 TWFLAG_VERIFY,
158 TWFLAG_CHECK,
159 TWFLAG_ALTDEVICE,
160 TWFLAG_NOTRIM,
161 TWFLAG_VOLDMANAGED,
162 TWFLAG_FORMATTABLE,
163 TWFLAG_RESIZE,
Ethan Yonker93382822018-11-01 15:25:31 -0500164 TWFLAG_KEYDIRECTORY,
Peter Cai28ea7b02019-05-24 11:38:54 +0800165 TWFLAG_WRAPPEDKEY,
Peter Cai439d60c2019-10-17 08:49:10 +0800166 TWFLAG_ADOPTED_MOUNT_DELAY,
Peter Caid68e6412019-11-02 19:22:38 +0800167 TWFLAG_DM_USE_ORIGINAL_PATH,
bigbiff998f8392021-08-06 19:19:33 -0400168 TWFLAG_LOGICAL,
Matt Mower2416a502016-04-12 19:54:46 -0500169};
170
171/* Flags without a trailing '=' are considered dual format flags and can be
172 * written as either 'flagname' or 'flagname=', where the character following
173 * the '=' is Y,y,1 for true and false otherwise.
174 */
175const struct flag_list tw_flags[] = {
176 { "andsec", TWFLAG_ANDSEC },
177 { "backup", TWFLAG_BACKUP },
178 { "backupname=", TWFLAG_BACKUPNAME },
179 { "blocksize=", TWFLAG_BLOCKSIZE },
180 { "canbewiped", TWFLAG_CANBEWIPED },
181 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
182 { "defaults", TWFLAG_DEFAULTS },
183 { "display=", TWFLAG_DISPLAY },
184 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500185 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500186 { "metadata_encryption=", TWFLAG_METADATA_ENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500187 { "flashimg", TWFLAG_FLASHIMG },
188 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
189 { "fsflags=", TWFLAG_FSFLAGS },
190 { "ignoreblkid", TWFLAG_IGNOREBLKID },
191 { "length=", TWFLAG_LENGTH },
192 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
Captain Throwbacke848afc2022-02-08 15:31:44 -0500193 { "quota", TWFLAG_QUOTA },
Matt Mower2416a502016-04-12 19:54:46 -0500194 { "removable", TWFLAG_REMOVABLE },
Matt Mower2416a502016-04-12 19:54:46 -0500195 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
196 { "storage", TWFLAG_STORAGE },
197 { "storagename=", TWFLAG_STORAGENAME },
198 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
199 { "symlink=", TWFLAG_SYMLINK },
200 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
201 { "usermrf", TWFLAG_USERMRF },
202 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
203 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600204 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600205 { "wait", TWFLAG_WAIT },
206 { "verify", TWFLAG_VERIFY },
207 { "check", TWFLAG_CHECK },
208 { "altdevice", TWFLAG_ALTDEVICE },
209 { "notrim", TWFLAG_NOTRIM },
210 { "voldmanaged=", TWFLAG_VOLDMANAGED },
211 { "formattable", TWFLAG_FORMATTABLE },
212 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500213 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Peter Cai28ea7b02019-05-24 11:38:54 +0800214 { "wrappedkey", TWFLAG_WRAPPEDKEY },
Peter Cai439d60c2019-10-17 08:49:10 +0800215 { "adopted_mount_delay=", TWFLAG_ADOPTED_MOUNT_DELAY },
Peter Caid68e6412019-11-02 19:22:38 +0800216 { "dm_use_original_path", TWFLAG_DM_USE_ORIGINAL_PATH },
bigbiff998f8392021-08-06 19:19:33 -0400217 { "logical", TWFLAG_LOGICAL },
Matt Mower2416a502016-04-12 19:54:46 -0500218 { 0, 0 },
219};
220
that9e0593e2014-10-08 00:01:24 +0200221TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400222 Can_Be_Mounted = false;
223 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500224 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200225 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400226 Wipe_During_Factory_Reset = false;
227 Wipe_Available_in_GUI = false;
228 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400229 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400230 SubPartition_Of = "";
231 Symlink_Path = "";
232 Symlink_Mount_Point = "";
233 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400234 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600235 Wildcard_Block_Device = false;
236 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400237 Actual_Block_Device = "";
238 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400239 Alternate_Block_Device = "";
240 Removable = false;
241 Is_Present = false;
242 Length = 0;
243 Size = 0;
244 Used = 0;
245 Free = 0;
246 Backup_Size = 0;
247 Can_Be_Encrypted = false;
248 Is_Encrypted = false;
249 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600250 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600251 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400252 Decrypted_Block_Device = "";
253 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500254 Backup_Display_Name = "";
255 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400256 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400257 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400258 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500259 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000260 Can_Encrypt_Backup = false;
261 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400262 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400263 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400264 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500265 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400266 Storage_Path = "";
267 Current_File_System = "";
268 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800269 Mount_Flags = 0;
270 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400271 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000272 Ignore_Blkid = false;
dianlujitao4879b372018-12-03 18:45:47 +0800273 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600274 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600275 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500276 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600277 Is_Adopted_Storage = false;
278 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600279 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500280 Key_Directory = "";
bigbiffee7b7ff2020-03-23 15:08:27 -0400281 Is_Super = false;
Peter Cai439d60c2019-10-17 08:49:10 +0800282 Adopted_Mount_Delay = 0;
Peter Caid68e6412019-11-02 19:22:38 +0800283 Original_Path = "";
284 Use_Original_Path = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400285}
286
287TWPartition::~TWPartition(void) {
288 // Do nothing
289}
290
bigbiff8da46fa2020-09-08 16:42:34 -0400291bool 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 -0500292 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500293 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400294 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500295 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500296 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600297 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
298 TWPartition *additional_entry = NULL;
299 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400300
Matt Mower2b2dd152016-04-26 11:24:08 -0500301 strlcpy(full_line, fstab_line, sizeof(full_line));
bigbiffee7b7ff2020-03-23 15:08:27 -0400302
Dees_Troy51127312012-09-08 13:08:49 -0400303 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500304 if (full_line[index] == 34)
305 skip = !skip;
306 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400307 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400308 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600309 if (line_len < 10)
310 return false; // There can't possibly be a valid fstab line that is less than 10 chars
bigbiff998f8392021-08-06 19:19:33 -0400311 if (fstab_line[0] == '#')
312 return false; // skip comments
313
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600314 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
315 fstab_version = 2;
316 block_device_index = 0;
317 mount_point_index = 1;
318 fs_index = 2;
319 }
320
bigbiff998f8392021-08-06 19:19:33 -0400321 if (fstab_line[0] != '/') {
bigbiffee7b7ff2020-03-23 15:08:27 -0400322 block_device_index = 0;
323 fstab_version = 2;
324 mount_point_index = 1;
325 fs_index = 2;
326 }
327
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600328 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400329 while (index < line_len) {
330 while (index < line_len && full_line[index] == '\0')
331 index++;
332 if (index >= line_len)
333 continue;
334 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600335 if (item_index == mount_point_index) {
336 Mount_Point = ptr;
bigbiffee7b7ff2020-03-23 15:08:27 -0400337 if (fstab_version == 2 && Is_Super == false) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600338 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
bigbiff8da46fa2020-09-08 16:42:34 -0400339 if (additional_entry) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600340 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
341 }
342 }
bigbiff8da46fa2020-09-08 16:42:34 -0400343 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600344 Backup_Path = Mount_Point;
345 Storage_Path = Mount_Point;
346 Display_Name = ptr + 1;
347 Backup_Display_Name = Display_Name;
348 Storage_Name = Display_Name;
349 item_index++;
350 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400351 // File System
352 Fstab_File_System = ptr;
353 Current_File_System = ptr;
354 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600355 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400356 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400357 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400358 MTD_Name = ptr;
359 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400360 } else if (Fstab_File_System == "bml") {
361 if (Mount_Point == "/boot")
362 MTD_Name = "boot";
363 else if (Mount_Point == "/recovery")
364 MTD_Name = "recovery";
365 Primary_Block_Device = ptr;
366 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000367 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 -0400368 } else {
369 Primary_Block_Device = ptr;
bigbiff998f8392021-08-06 19:19:33 -0400370 if (*ptr == '/')
371 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400372 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400373 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600374 } else if (item_index > 2) {
375 if (fstab_version == 2) {
376 if (item_index == 3) {
377 Process_FS_Flags(ptr);
378 if (additional_entry) {
379 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
380 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
381 }
382 } else {
383 strlcpy(twflags, ptr, sizeof(twflags));
384 }
385 item_index++;
386 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400387 // Alternate Block Device
388 Alternate_Block_Device = ptr;
389 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
390 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
391 // Partition length
392 ptr += 7;
393 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400394 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
395 // Custom flags, save for later so that new values aren't overwritten by defaults
396 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500397 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400398 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
399 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400400 } else {
401 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500402 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400403 }
404 }
405 while (index < line_len && full_line[index] != '\0')
406 index++;
407 }
408
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600409 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
410 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
411 it = twrp_flags->find(Mount_Point);
412 if (it != twrp_flags->end()) {
413 if (!it->second.Primary_Block_Device.empty()) {
414 Primary_Block_Device = it->second.Primary_Block_Device;
415 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
416 }
417 if (!it->second.Alternate_Block_Device.empty()) {
418 Alternate_Block_Device = it->second.Alternate_Block_Device;
419 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
420 }
421 }
422 }
423
424 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
425 Sysfs_Entry = Primary_Block_Device;
426 Primary_Block_Device = "";
427 Is_Storage = true;
428 Removable = true;
429 Wipe_Available_in_GUI = true;
430 Wildcard_Block_Device = true;
431 }
432 if (Primary_Block_Device.find("*") != string::npos)
433 Wildcard_Block_Device = true;
434
bigbiff8da46fa2020-09-08 16:42:34 -0400435 if (Mount_Point == "auto") {
436 Mount_Point = "/auto";
437 char autoi[5];
438 sprintf(autoi, "%i", auto_index);
439 Mount_Point += autoi;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600440 Backup_Path = Mount_Point;
441 Storage_Path = Mount_Point;
dianlujitaob76a73a2020-04-30 20:33:20 +0800442 Backup_Name = Mount_Point.substr(1);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600443 auto_index++;
444 Setup_File_System(Display_Error);
445 Display_Name = "Storage";
446 Backup_Display_Name = Display_Name;
447 Storage_Name = Display_Name;
448 Can_Be_Backed_Up = false;
449 Wipe_Available_in_GUI = true;
450 Is_Storage = true;
451 Removable = true;
452 Wipe_Available_in_GUI = true;
453 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400454 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000455 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400456 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000457 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500458 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400459 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400460 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400461 Setup_File_System(Display_Error);
dianlujitaob76a73a2020-04-30 20:33:20 +0800462 Backup_Name = Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
Chaosmaster3b682732020-01-25 21:09:28 +0100463 if (Mount_Point == "/" || Mount_Point == "/system" || Mount_Point == "/system_root") {
bigbiff8da46fa2020-09-08 16:42:34 -0400464 Mount_Point = PartitionManager.Get_Android_Root_Path();
465 Backup_Path = Mount_Point;
466 Storage_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400467 Display_Name = "System";
dianlujitaob76a73a2020-04-30 20:33:20 +0800468 Backup_Name = "system";
Dees_Troya13d74f2013-03-24 08:54:55 -0500469 Backup_Display_Name = Display_Name;
470 Storage_Name = Display_Name;
bigbiff8da46fa2020-09-08 16:42:34 -0400471 Wipe_Available_in_GUI = false;
472 Can_Be_Backed_Up = false;
473 Can_Be_Wiped = false;
bigbiff8da46fa2020-09-08 16:42:34 -0400474 Make_Dir(PartitionManager.Get_Android_Root_Path(), true);
me-cafebabea021ac22022-07-29 06:34:45 +0800475 } else if (Mount_Point == "/system_ext") {
476 Display_Name = "System_EXT";
477 Backup_Name = "System_EXT";
478 Backup_Display_Name = Display_Name;
479 Storage_Name = Display_Name;
480 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Mohd Faraze3948ec2020-08-14 01:40:59 +0000481 } else if (Mount_Point == "/product") {
482 Display_Name = "Product";
483 Backup_Name = "Product";
484 Backup_Display_Name = Display_Name;
485 Storage_Name = Display_Name;
486 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Mohd Faraze3948ec2020-08-14 01:40:59 +0000487 } else if (Mount_Point == "/odm") {
488 Display_Name = "ODM";
489 Backup_Name = "ODM";
490 Backup_Display_Name = Display_Name;
491 Storage_Name = Display_Name;
492 Can_Be_Backed_Up = Wipe_Available_in_GUI = Is_Super ? false : true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400493 } else if (Mount_Point == "/data") {
494 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500495 Backup_Display_Name = Display_Name;
496 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400497 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400498 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500499 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000500 Can_Encrypt_Backup = true;
501 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400502 } else if (Mount_Point == "/cache") {
503 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500504 Backup_Display_Name = Display_Name;
505 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400506 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400507 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500508 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400509 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400510 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400511 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500512 Backup_Display_Name = Display_Name;
513 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400514 Is_SubPartition = true;
515 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400516 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500517 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000518 Can_Encrypt_Backup = true;
519 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400520 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400521 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400522 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500523 Backup_Display_Name = Display_Name;
524 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400525 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400526 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500527 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000528 Can_Encrypt_Backup = true;
529 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400530 } else if (Mount_Point == "/boot") {
531 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500532 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400533 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500534 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500535 } else if (Mount_Point == "/vendor") {
536 Display_Name = "Vendor";
537 Backup_Display_Name = Display_Name;
538 Storage_Name = Display_Name;
Dees_Troy8170a922012-09-18 15:40:25 -0400539 }
540#ifdef TW_EXTERNAL_STORAGE_PATH
541 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
542 Is_Storage = true;
543 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400544 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500545 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400546#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000547 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400548 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400549 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500550 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400551#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000552 }
Dees_Troy8170a922012-09-18 15:40:25 -0400553#ifdef TW_INTERNAL_STORAGE_PATH
554 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
555 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500556 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400557 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500558 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400559 }
560#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000561 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400562 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500563 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500564 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400565 }
566#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400567 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400568 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600569 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500570 if (Mount_Point == "/boot") {
571 Display_Name = "Boot";
572 Backup_Display_Name = Display_Name;
573 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600574 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500575 } else if (Mount_Point == "/recovery") {
576 Display_Name = "Recovery";
577 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600578 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500579 } else if (Mount_Point == "/system_image") {
580 Display_Name = "System Image";
581 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500582 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500583 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500584 } else if (Mount_Point == "/vendor_image") {
585 Display_Name = "Vendor Image";
586 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500587 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500588 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500589 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400590 }
591
Matt Mower2416a502016-04-12 19:54:46 -0500592 // Process TWRP fstab flags
593 if (strlen(twflags) > 0) {
594 string Prev_Display_Name = Display_Name;
595 string Prev_Storage_Name = Storage_Name;
596 string Prev_Backup_Display_Name = Backup_Display_Name;
597 Display_Name = "";
598 Storage_Name = "";
599 Backup_Display_Name = "";
600
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600601 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
602 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500603
604 bool has_display_name = !Display_Name.empty();
605 bool has_storage_name = !Storage_Name.empty();
606 bool has_backup_name = !Backup_Display_Name.empty();
607 if (!has_display_name) Display_Name = Prev_Display_Name;
608 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
609 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
610
611 if (has_display_name && !has_storage_name)
612 Storage_Name = Display_Name;
613 if (!has_display_name && has_storage_name)
614 Display_Name = Storage_Name;
615 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
616 Backup_Display_Name = Display_Name;
617 if (!has_display_name && has_backup_name)
618 Display_Name = Backup_Display_Name;
619 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600620
621 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
622 it = twrp_flags->find(Mount_Point);
623 if (it != twrp_flags->end()) {
624 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
625 int skip = 0;
626 string Flags = it->second.Flags;
627 strcpy(twrpflags, Flags.c_str());
628 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
629 skip += strlen("flags=");
630 char* flagptr = twrpflags;
631 flagptr += skip;
632 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
633 }
634 }
nkk7198fc3992017-12-16 16:26:42 +0200635
636 if (Mount_Point == "/persist" && Can_Be_Mounted) {
637 bool mounted = Is_Mounted();
638 if (mounted || Mount(false)) {
nkk7198fc3992017-12-16 16:26:42 +0200639 TWFunc::Fixup_Time_On_Boot("/persist/time/");
640 if (!mounted)
641 UnMount(false);
642 }
643 }
644
Dees_Troy51127312012-09-08 13:08:49 -0400645 return true;
646}
647
Matt Mower72c87ce2016-04-26 14:34:56 -0500648void TWPartition::Partition_Post_Processing(bool Display_Error) {
649 if (Mount_Point == "/data")
650 Setup_Data_Partition(Display_Error);
651 else if (Mount_Point == "/cache")
652 Setup_Cache_Partition(Display_Error);
653}
654
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600655void TWPartition::ExcludeAll(const string& path) {
656 backup_exclusions.add_absolute_dir(path);
657 wipe_exclusions.add_absolute_dir(path);
658}
659
Matt Mower72c87ce2016-04-26 14:34:56 -0500660void TWPartition::Setup_Data_Partition(bool Display_Error) {
661 if (Mount_Point != "/data")
662 return;
663
664 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
665 UnMount(false);
666
667#ifdef TW_INCLUDE_CRYPTO
Darth98bc9da52023-02-05 23:41:03 +0000668 #ifdef TW_PREPARE_DATA_MEDIA_EARLY
669 if (datamedia)
670 Setup_Data_Media();
671 #endif
Matt Mower72c87ce2016-04-26 14:34:56 -0500672 Can_Be_Encrypted = true;
673 char crypto_blkdev[255];
674 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
675 if (strcmp(crypto_blkdev, "error") != 0) {
bigbiff7ba75002020-04-11 20:47:09 -0400676 Set_FBE_Status();
Matt Mower72c87ce2016-04-26 14:34:56 -0500677 Decrypted_Block_Device = crypto_blkdev;
678 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
Darth98bc9da52023-02-05 23:41:03 +0000679 #ifndef TW_PREPARE_DATA_MEDIA_EARLY
bigbiffcda15882021-12-30 17:01:44 -0500680 if (datamedia)
681 Setup_Data_Media();
Darth98bc9da52023-02-05 23:41:03 +0000682 #endif
bigbiff7ba75002020-04-11 20:47:09 -0400683 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500684 } else if (!Mount(false)) {
685 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500686 if (Key_Directory.empty()) {
Peter Caid68e6412019-11-02 19:22:38 +0800687 set_partition_data(Use_Original_Path ? Original_Path.c_str() : Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(),
Noah Jacobson81d638d2019-04-28 00:10:07 -0400688 Fstab_File_System.c_str());
Ethan Yonker93382822018-11-01 15:25:31 -0500689 if (cryptfs_check_footer() == 0) {
690 Is_Encrypted = true;
691 Is_Decrypted = false;
692 Can_Be_Mounted = false;
693 Current_File_System = "emmc";
694 Setup_Image();
Ethan Yonker93382822018-11-01 15:25:31 -0500695 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Noah Jacobson81d638d2019-04-28 00:10:07 -0400696 DataManager::SetValue("tw_crypto_pwtype_0", cryptfs_get_password_type());
Ethan Yonker93382822018-11-01 15:25:31 -0500697 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
698 DataManager::SetValue("tw_crypto_display", "");
bigbiffcda15882021-12-30 17:01:44 -0500699 if (datamedia)
700 Setup_Data_Media();
Ethan Yonker93382822018-11-01 15:25:31 -0500701 } else {
702 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
703 }
704 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500705 Is_Encrypted = true;
706 Is_Decrypted = false;
bigbiffbee26852022-02-09 20:49:00 -0500707 if (datamedia)
708 Setup_Data_Media();
Matt Mower72c87ce2016-04-26 14:34:56 -0500709 }
Ethan Yonker93382822018-11-01 15:25:31 -0500710 } else if (Key_Directory.empty()) {
Noah Jacobson81d638d2019-04-28 00:10:07 -0400711 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n",
712 Primary_Block_Device.c_str(), Mount_Point.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500713 }
714 } else {
bigbiff7ba75002020-04-11 20:47:09 -0400715 Set_FBE_Status();
Captain Throwbackacc7f0f2020-12-29 15:54:33 -0500716 int is_device_fbe;
717 DataManager::GetValue(TW_IS_FBE, is_device_fbe);
Captain Throwback8a8e56c2021-10-01 15:12:24 -0400718 char crypto_state[255];
719 property_get("ro.crypto.state", crypto_state, "error");
720 if (!Decrypt_FBE_DE() && strcmp(crypto_state, "error") != 0) {
721 if (is_device_fbe == 1)
722 LOGERR("Unable to decrypt FBE device\n");
723 } else {
724 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Darth98bc9da52023-02-05 23:41:03 +0000725 #ifndef TW_PREPARE_DATA_MEDIA_EARLY
bigbiffcda15882021-12-30 17:01:44 -0500726 if (datamedia)
727 Setup_Data_Media();
Darth98bc9da52023-02-05 23:41:03 +0000728 #endif
mauronofrio9bf73352019-11-23 22:27:34 +0100729 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500730 }
731 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
732 Setup_Data_Media();
bigbiff25d25b92020-06-19 16:07:38 -0400733 Recreate_Media_Folder();
Matt Mower72c87ce2016-04-26 14:34:56 -0500734 }
735#else
736 if (datamedia) {
737 Setup_Data_Media();
738 Recreate_Media_Folder();
739 }
740#endif
741}
742
bigbiff7ba75002020-04-11 20:47:09 -0400743void TWPartition::Set_FBE_Status() {
744 DataManager::SetValue(TW_IS_DECRYPTED, 1);
745 Is_Encrypted = true;
746 Is_Decrypted = true;
bigbiff7ba75002020-04-11 20:47:09 -0400747 if (Key_Directory.empty()) {
748 Is_FBE = false;
749 DataManager::SetValue(TW_IS_FBE, 0);
750 } else {
Captain Throwbackb5af4f82020-12-29 16:01:10 -0500751 LOGINFO("Setup_Data_Partition::Key_Directory::%s\n", Key_Directory.c_str());
bigbiff7ba75002020-04-11 20:47:09 -0400752 Is_FBE = true;
753 DataManager::SetValue(TW_IS_FBE, 1);
754 }
755}
756
Ethan Yonker93382822018-11-01 15:25:31 -0500757bool TWPartition::Decrypt_FBE_DE() {
bigbiff7ba75002020-04-11 20:47:09 -0400758 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
Captain Throwback87d73d62020-02-17 16:44:50 -0500759 DataManager::SetValue(TW_IS_FBE, 1);
Captain Throwback37c3aef2021-10-06 11:38:18 -0400760 PartitionManager.Set_Crypto_State();
761 PartitionManager.Set_Crypto_Type("file");
Ethan Yonker93382822018-11-01 15:25:31 -0500762 LOGINFO("File Based Encryption is present\n");
763#ifdef TW_INCLUDE_FBE
Noah Jacobson81d638d2019-04-28 00:10:07 -0400764 Is_FBE = true;
765 ExcludeAll(Mount_Point + "/convert_fbe");
766 ExcludeAll(Mount_Point + "/unencrypted");
767 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
768 ExcludeAll(Mount_Point + "/misc/vold/volume_keys");
769 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
770 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
771 ExcludeAll(Mount_Point + "/system/locksettings.db");
772 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
773 ExcludeAll(Mount_Point + "/misc/gatekeeper");
774 ExcludeAll(Mount_Point + "/misc/keystore");
775 ExcludeAll(Mount_Point + "/drm/kek.dat");
bigbiffa957f072021-03-07 18:20:29 -0500776 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt synthetic password
micky3872ec1df42021-10-14 14:53:06 +0200777 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.password.key");
778 ExcludeAll(Mount_Point + "/system/users/0/gatekeeper.pattern.key");
Noah Jacobson81d638d2019-04-28 00:10:07 -0400779 ExcludeAll(Mount_Point + "/cache");
780 ExcludeAll(Mount_Point + "/per_boot"); // removed each boot by init
bigbiffa15d02f2021-06-29 20:04:54 -0400781 ExcludeAll(Mount_Point + "/gsi"); // cow devices
782
Noah Jacobson81d638d2019-04-28 00:10:07 -0400783 int retry_count = 3;
784 while (!Decrypt_DE() && --retry_count)
785 usleep(2000);
786 if (retry_count > 0) {
Captain Throwback37c3aef2021-10-06 11:38:18 -0400787 PartitionManager.Set_Crypto_State();
Noah Jacobson81d638d2019-04-28 00:10:07 -0400788 Is_Encrypted = true;
789 Is_Decrypted = false;
790 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
791 string filename;
792 int pwd_type = Get_Password_Type(0, filename);
793 if (pwd_type < 0) {
794 LOGERR("This TWRP does not have synthetic password decrypt support\n");
795 pwd_type = 0; // default password
Ethan Yonker93382822018-11-01 15:25:31 -0500796 }
Noah Jacobson81d638d2019-04-28 00:10:07 -0400797 PartitionManager.Parse_Users(); // after load_all_de_keys() to parse_users
798 std::vector<users_struct>::iterator iter;
799 std::vector<users_struct>* userList = PartitionManager.Get_Users_List();
800 for (iter = userList->begin(); iter != userList->end(); iter++) {
801 if (atoi((*iter).userId.c_str()) != 0) {
802 ExcludeAll(Mount_Point + "/system_de/" + (*iter).userId + "/spblob");
803 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.password.key");
804 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/gatekeeper.pattern.key");
805 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db");
806 ExcludeAll(Mount_Point + "/system/users/" + (*iter).userId + "/locksettings.db-wal");
807 }
808 }
809 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
810 DataManager::SetValue("tw_crypto_pwtype_0", pwd_type);
811 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
812 DataManager::SetValue("tw_crypto_display", "");
813 return true;
814 }
Ethan Yonker93382822018-11-01 15:25:31 -0500815#else
816 LOGERR("FBE found but FBE support not present in TWRP\n");
817#endif
818 }
Captain Throwback87d73d62020-02-17 16:44:50 -0500819 DataManager::SetValue(TW_IS_FBE, 0);
Ethan Yonker93382822018-11-01 15:25:31 -0500820 return false;
821}
822
Matt Mower72c87ce2016-04-26 14:34:56 -0500823void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
824 if (Mount_Point != "/cache")
825 return;
826
827 if (!Mount(true))
828 return;
829
830 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
831 LOGINFO("Recreating /cache/recovery folder\n");
832 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
833 LOGERR("Could not create /cache/recovery\n");
834 }
835}
836
Matt Mower4ab42b12016-04-21 13:52:18 -0500837void TWPartition::Process_FS_Flags(const char *str) {
838 char *options = strdup(str);
839 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800840
Matt Mower4ab42b12016-04-21 13:52:18 -0500841 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800842
Matt Mower4ab42b12016-04-21 13:52:18 -0500843 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600844 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
845 char *equals = strstr(ptr, "=");
846 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500847
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600848 if (!equals)
849 name_len = strlen(ptr);
850 else
851 name_len = equals - ptr;
852
853 // There are some flags that we want to ignore in TWRP
854 bool found_match = false;
855 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
856 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
857 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800858 break;
859 }
860 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600861 if (found_match)
862 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800863
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600864 // mount_flags are never postfixed by '='
865 if (!equals) {
866 const struct flag_list* mount_flag = mount_flags;
867 for (; mount_flag->name; mount_flag++) {
868 if (strcmp(ptr, mount_flag->name) == 0) {
869 if (mount_flag->flag == MS_RDONLY)
870 Mount_Read_Only = true;
871 else
872 Mount_Flags |= (unsigned)mount_flag->flag;
873 found_match = true;
874 break;
875 }
876 }
877 if (found_match)
878 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500879 }
880
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600881 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
882 if (!Mount_Options.empty())
883 Mount_Options += ",";
884 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500885 }
886 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800887}
888
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600889void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
890 partition_fs_flags_struct flags;
891 flags.File_System = local_File_System;
892 flags.Mount_Flags = local_Mount_Flags;
893 flags.Mount_Options = local_Mount_Options;
894 fs_flags.push_back(flags);
895}
896
Matt Mower2416a502016-04-12 19:54:46 -0500897void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
898 switch (flag) {
899 case TWFLAG_ANDSEC:
900 Has_Android_Secure = val;
901 break;
902 case TWFLAG_BACKUP:
903 Can_Be_Backed_Up = val;
904 break;
905 case TWFLAG_BACKUPNAME:
906 Backup_Display_Name = str;
907 break;
908 case TWFLAG_BLOCKSIZE:
909 Format_Block_Size = (unsigned long)(atol(str));
910 break;
911 case TWFLAG_CANBEWIPED:
912 Can_Be_Wiped = val;
913 break;
914 case TWFLAG_CANENCRYPTBACKUP:
915 Can_Encrypt_Backup = val;
916 break;
917 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600918 case TWFLAG_WAIT:
919 case TWFLAG_VERIFY:
920 case TWFLAG_CHECK:
921 case TWFLAG_NOTRIM:
922 case TWFLAG_VOLDMANAGED:
923 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500924 // Do nothing
925 break;
926 case TWFLAG_DISPLAY:
927 Display_Name = str;
928 break;
929 case TWFLAG_ENCRYPTABLE:
930 case TWFLAG_FORCEENCRYPT:
931 Crypto_Key_Location = str;
932 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500933 case TWFLAG_FILEENCRYPTION:
934 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
935 // fileencryption=ice:aes-256-heh
936 {
937 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500938 size_t colon_loc = FBE.find(":");
939 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500940 property_set("fbe.contents", FBE.c_str());
941 property_set("fbe.filenames", "");
942 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500943 break;
944 }
Ethan Yonker93382822018-11-01 15:25:31 -0500945 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500946 FBE_contents = FBE.substr(0, colon_loc);
947 FBE_filenames = FBE.substr(colon_loc + 1);
948 property_set("fbe.contents", FBE_contents.c_str());
949 property_set("fbe.filenames", FBE_filenames.c_str());
950 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
951 }
952 break;
Captain Throwback32bcdcd2022-02-08 12:45:01 -0500953 case TWFLAG_METADATA_ENCRYPTION:
954 // This flag isn't used by TWRP but is needed for FBEv2 metadata decryption
955 // metadata_encryption=aes-256-xts:wrappedkey_v0
956 {
957 std::string META = str;
958 size_t colon_loc = META.find(":");
959 if (colon_loc == std::string::npos) {
960 property_set("metadata.contents", META.c_str());
961 property_set("metadata.filenames", "");
962 LOGINFO("Metadata contents '%s', filenames ''\n", META.c_str());
963 break;
964 }
965 std::string META_contents, META_filenames;
966 META_contents = META.substr(0, colon_loc);
967 META_filenames = META.substr(colon_loc + 1);
968 property_set("metadata.contents", META_contents.c_str());
969 property_set("metadata.filenames", META_filenames.c_str());
970 LOGINFO("Metadata contents '%s', filenames '%s'\n", META_contents.c_str(), META_filenames.c_str());
971 }
972 break;
Peter Cai28ea7b02019-05-24 11:38:54 +0800973 case TWFLAG_WRAPPEDKEY:
bigbiff437d86f2021-09-26 16:57:14 -0400974 // no more processing needed. leaving it here in case we want to do something in the future
Peter Cai28ea7b02019-05-24 11:38:54 +0800975 break;
Matt Mower2416a502016-04-12 19:54:46 -0500976 case TWFLAG_FLASHIMG:
977 Can_Flash_Img = val;
978 break;
979 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500980 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500981 break;
982 case TWFLAG_IGNOREBLKID:
983 Ignore_Blkid = val;
984 break;
985 case TWFLAG_LENGTH:
986 Length = atoi(str);
987 break;
988 case TWFLAG_MOUNTTODECRYPT:
989 Mount_To_Decrypt = val;
990 break;
Captain Throwbacke848afc2022-02-08 15:31:44 -0500991 case TWFLAG_QUOTA:
992 // Filesystem flag - TWRP does not need to process
993 break;
Matt Mower2416a502016-04-12 19:54:46 -0500994 case TWFLAG_REMOVABLE:
995 Removable = val;
996 break;
Matt Mower2416a502016-04-12 19:54:46 -0500997 case TWFLAG_SETTINGSSTORAGE:
998 Is_Settings_Storage = val;
999 if (Is_Settings_Storage)
1000 Is_Storage = true;
1001 break;
1002 case TWFLAG_STORAGE:
1003 Is_Storage = val;
1004 break;
1005 case TWFLAG_STORAGENAME:
1006 Storage_Name = str;
1007 break;
1008 case TWFLAG_SUBPARTITIONOF:
1009 Is_SubPartition = true;
1010 SubPartition_Of = str;
1011 break;
1012 case TWFLAG_SYMLINK:
1013 Symlink_Path = str;
1014 break;
1015 case TWFLAG_USERDATAENCRYPTBACKUP:
1016 Use_Userdata_Encryption = val;
1017 if (Use_Userdata_Encryption)
1018 Can_Encrypt_Backup = true;
1019 break;
1020 case TWFLAG_USERMRF:
1021 Use_Rm_Rf = val;
1022 break;
1023 case TWFLAG_WIPEDURINGFACTORYRESET:
1024 Wipe_During_Factory_Reset = val;
1025 if (Wipe_During_Factory_Reset) {
1026 Can_Be_Wiped = true;
1027 Wipe_Available_in_GUI = true;
1028 }
1029 break;
1030 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001031 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -05001032 Wipe_Available_in_GUI = val;
1033 if (Wipe_Available_in_GUI)
1034 Can_Be_Wiped = true;
1035 break;
Ethan Yonker1b190162016-12-05 15:25:19 -06001036 case TWFLAG_SLOTSELECT:
1037 SlotSelect = true;
1038 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001039 case TWFLAG_ALTDEVICE:
1040 Alternate_Block_Device = str;
1041 break;
Peter Cai439d60c2019-10-17 08:49:10 +08001042 case TWFLAG_ADOPTED_MOUNT_DELAY:
1043 Adopted_Mount_Delay = atoi(str);
1044 break;
Ethan Yonker93382822018-11-01 15:25:31 -05001045 case TWFLAG_KEYDIRECTORY:
1046 Key_Directory = str;
bigbiffa957f072021-03-07 18:20:29 -05001047 LOGINFO("setting Key_Directory to: %s\n", Key_Directory.c_str());
bigbiffd58ba182020-03-23 10:02:29 -04001048 break;
Peter Caid68e6412019-11-02 19:22:38 +08001049 case TWFLAG_DM_USE_ORIGINAL_PATH:
1050 Use_Original_Path = true;
1051 break;
bigbiff998f8392021-08-06 19:19:33 -04001052 case TWFLAG_LOGICAL:
1053 Is_Super = true;
1054 break;
Matt Mower2416a502016-04-12 19:54:46 -05001055 default:
1056 // Should not get here
1057 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
1058 break;
1059 }
1060}
Dees_Troy51127312012-09-08 13:08:49 -04001061
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001062void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -05001063 char separator[2] = {'\n', 0};
1064 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001065 char source_separator = ';';
1066
1067 if (fstab_ver == 2)
1068 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -05001069
1070 // Semicolons within double-quotes are not forbidden, so replace
1071 // only the semicolons intended as separators with '\n' for strtok
1072 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
1073 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -05001074 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001075 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -05001076 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -04001077 }
1078
Matt Mower2416a502016-04-12 19:54:46 -05001079 // Avoid issues with potentially nested strtok by using strtok_r
1080 ptr = strtok_r(flags, separator, &savep);
1081 while (ptr) {
1082 int ptr_len = strlen(ptr);
1083 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -08001084
Matt Mower2416a502016-04-12 19:54:46 -05001085 for (; tw_flag->name; tw_flag++) {
1086 int flag_len = strlen(tw_flag->name);
1087
1088 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
1089 bool flag_val = false;
1090
1091 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
1092 && ptr[flag_len] != '=') {
1093 // Handle flags with same starting string
1094 // (e.g. backup and backupname)
1095 continue;
1096 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
1097 // Handle flags with dual format: Part 1
1098 // (e.g. backup and backup=y. backup=y handled here)
1099 ptr += flag_len + 1;
1100 TWFunc::Strip_Quotes(ptr);
1101 // Skip flags with empty argument
1102 // (e.g. backup=)
1103 if (strlen(ptr) == 0) {
1104 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
1105 break;
1106 }
1107 flag_val = strchr("yY1", *ptr) != NULL;
1108 } else if (ptr_len == flag_len
1109 && (tw_flag->name)[flag_len-1] == '=') {
1110 // Skip flags missing argument after =
1111 // (e.g. backupname=)
1112 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1113 break;
1114 } else if (ptr_len > flag_len
1115 && (tw_flag->name)[flag_len-1] == '=') {
1116 // Handle arguments to flags
1117 // (e.g. backupname="My Stuff")
1118 ptr += flag_len;
1119 TWFunc::Strip_Quotes(ptr);
1120 // Skip flags with empty argument
1121 // (e.g. backupname="")
1122 if (strlen(ptr) == 0) {
1123 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1124 break;
1125 }
1126 } else if (ptr_len == flag_len) {
1127 // Handle flags with dual format: Part 2
1128 // (e.g. backup and backup=y. backup handled here)
1129 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001130 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001131 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1132 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001133 }
Matt Mower2416a502016-04-12 19:54:46 -05001134
1135 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1136 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001137 }
Matt Mower2416a502016-04-12 19:54:46 -05001138 }
1139 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001140 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001141 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001142 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001143 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001144 }
Matt Mower2416a502016-04-12 19:54:46 -05001145 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001146 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001147}
1148
Dees_Troy5bf43922012-09-07 16:07:55 -04001149bool TWPartition::Is_File_System(string File_System) {
1150 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001151 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001152 File_System == "ext4" ||
1153 File_System == "vfat" ||
1154 File_System == "ntfs" ||
1155 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001156 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001157 File_System == "f2fs" ||
GarfieldHand0b854b2021-11-21 23:46:20 +08001158 File_System == "erofs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001159 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001160 File_System == "auto")
1161 return true;
1162 else
1163 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001164}
1165
Dees_Troy5bf43922012-09-07 16:07:55 -04001166bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001167 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001168 return true;
1169 else
1170 return false;
1171}
1172
Dees_Troy51127312012-09-08 13:08:49 -04001173bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001174 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1175 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001176 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001177 if (mkdir(Path.c_str(), 0777) == -1) {
1178 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001179 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001180 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001181 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001182 return false;
1183 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001184 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001185 return true;
1186 }
1187 }
1188 return true;
1189}
1190
Dees_Troy5bf43922012-09-07 16:07:55 -04001191void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001192 Can_Be_Mounted = true;
1193 Can_Be_Wiped = true;
1194
Dees_Troy5bf43922012-09-07 16:07:55 -04001195 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001196 Make_Dir(Mount_Point, Display_Error);
bigbiffce8f83c2015-12-12 18:30:21 -05001197 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001198}
1199
Ethan Yonker1b190162016-12-05 15:25:19 -06001200void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001201 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1202 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001203 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001204 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001205 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001206 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001207 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001208 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 -04001209}
1210
Dees_Troye58d5262012-09-21 12:27:57 -04001211void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001212 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001213 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001214 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001215 Has_Android_Secure = true;
1216 Symlink_Path = Mount_Point + "/.android_secure";
1217 Symlink_Mount_Point = "/and-sec";
1218 Backup_Path = Symlink_Mount_Point;
1219 Make_Dir("/and-sec", true);
1220 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001221 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001222}
1223
that9e0593e2014-10-08 00:01:24 +02001224void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001225 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001226 if (Storage_Name.empty() || Storage_Name == "Data")
1227 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001228 Has_Data_Media = true;
1229 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001230 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001231 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001232 if (Mount_Point == "/data") {
1233 Is_Settings_Storage = true;
1234 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1235 Make_Dir("/emmc", false);
1236 Symlink_Mount_Point = "/emmc";
1237 } else {
1238 Make_Dir("/sdcard", false);
1239 Symlink_Mount_Point = "/sdcard";
1240 }
Darth98bc9da52023-02-05 23:41:03 +00001241 #ifdef TW_PREPARE_DATA_MEDIA_EARLY
1242 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1243 #else
bigbiffcda15882021-12-30 17:01:44 -05001244 Mount(false);
1245 if (TWFunc::Path_Exists(Mount_Point + "/media/0")) {
Darth98bc9da52023-02-05 23:41:03 +00001246 #endif
Ethan Yonker66a19492015-12-10 10:19:45 -06001247 Storage_Path = Mount_Point + "/media/0";
1248 Symlink_Path = Storage_Path;
1249 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1250 UnMount(true);
1251 }
1252 DataManager::SetValue("tw_has_internal", 1);
1253 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001254 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
bigbiff25d25b92020-06-19 16:07:38 -04001255 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 +01001256 backup_exclusions.add_absolute_dir("/data/vendor/dumpsys");
bigbiff25d25b92020-06-19 16:07:38 -04001257 backup_exclusions.add_absolute_dir("/data/cache");
nijel880c92d92022-01-14 10:01:32 -05001258 backup_exclusions.add_absolute_dir("/data/misc/apexdata/com.android.art"); // exclude this dir to prevent "error 255" on AOSP Android 12
sekaiacgf4af5f12022-07-06 11:19:45 +08001259 backup_exclusions.add_absolute_dir("/data/extm"); //exclude this dir to prevent "error 255" on MIUI
Ethan Yonker6355b562017-05-01 09:42:17 -05001260 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001261 ExcludeAll(Mount_Point + "/system/storage.xml");
Darth98c5088d2022-08-09 12:54:40 +01001262
1263 // board-customisable exclusions
1264 #ifdef TW_BACKUP_EXCLUSIONS
1265 std::vector<std::string> user_extra_exclusions = TWFunc::Split_String(TW_BACKUP_EXCLUSIONS, ",");
1266 std::string s1;
1267 for (const std::string& extra_x : user_extra_exclusions) {
1268 s1 = android::base::Trim(extra_x);
1269 if (!s1.empty()) {
1270 backup_exclusions.add_absolute_dir(s1);
1271 LOGINFO("Adding user-defined path '%s' to the backup exclusions\n", s1.c_str());
1272 }
1273 }
1274 #endif
Ethan Yonker6277c792014-09-15 14:54:30 -05001275 } else {
nkk713c1e35f2017-03-24 18:28:03 +02001276 int i;
1277 string path;
1278 for (i = 2; i <= 9; i++) {
1279 path = "/sdcard" + TWFunc::to_string(i);
1280 if (!TWFunc::Path_Exists(path)) {
1281 Make_Dir(path, false);
1282 Symlink_Mount_Point = path;
1283 LOGINFO("'%s' data/media emulated storage symlinked to %s.\n", Mount_Point.c_str(), Symlink_Mount_Point.c_str());
1284 break;
1285 }
1286 }
Ethan Yonker66a19492015-12-10 10:19:45 -06001287 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1288 Storage_Path = Mount_Point + "/media/0";
1289 Symlink_Path = Storage_Path;
1290 UnMount(true);
1291 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001292 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001293 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001294}
1295
Dees_Troy5bf43922012-09-07 16:07:55 -04001296void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001297 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001298
Peter Caid68e6412019-11-02 19:22:38 +08001299 Original_Path = Block;
1300
Dees_Troy5bf43922012-09-07 16:07:55 -04001301 strcpy(device, Block.c_str());
1302 memset(realDevice, 0, sizeof(realDevice));
1303 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1304 {
1305 strcpy(device, realDevice);
1306 memset(realDevice, 0, sizeof(realDevice));
1307 }
1308
bigbiff998f8392021-08-06 19:19:33 -04001309 Block = device;
1310 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001311}
1312
Kjell Braden3126a112016-06-19 16:58:15 +00001313bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001314 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001315 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001316 int retry_count = 5;
1317 while (retry_count > 0 && !Mount(false)) {
1318 usleep(500000);
1319 retry_count--;
1320 }
Kjell Braden3126a112016-06-19 16:58:15 +00001321 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001322 }
Kjell Braden3126a112016-06-19 16:58:15 +00001323 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001324}
1325
Dees_Troy38bd7602012-09-14 13:33:53 -04001326bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1327 FILE *fp = NULL;
1328 char line[255];
1329
1330 fp = fopen("/proc/mtd", "rt");
1331 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001332 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001333 return false;
1334 }
1335
1336 while (fgets(line, sizeof(line), fp) != NULL)
1337 {
1338 char device[32], label[32];
1339 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001340 int deviceId;
1341
1342 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1343
1344 // Skip header and blank lines
1345 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1346 continue;
1347
1348 // Strip off the trailing " from the label
1349 label[strlen(label)-1] = '\0';
1350
1351 if (strcmp(label, MTD_Name.c_str()) == 0) {
1352 // We found our device
1353 // Strip off the trailing : from the device
1354 device[strlen(device)-1] = '\0';
1355 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1356 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1357 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001358 fclose(fp);
1359 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001360 }
1361 }
1362 }
1363 fclose(fp);
1364
1365 return false;
1366}
1367
Dees_Troy51127312012-09-08 13:08:49 -04001368bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1369 struct statfs st;
1370 string Local_Path = Mount_Point + "/.";
1371
1372 if (!Mount(Display_Error))
1373 return false;
1374
1375 if (statfs(Local_Path.c_str(), &st) != 0) {
1376 if (!Removable) {
1377 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001378 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001379 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001380 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001381 }
1382 return false;
1383 }
1384 Size = (st.f_blocks * st.f_bsize);
1385 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1386 Free = (st.f_bfree * st.f_bsize);
1387 Backup_Size = Used;
1388 return true;
1389}
1390
1391bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001392 FILE* fp;
1393 char command[255], line[512];
1394 int include_block = 1;
1395 unsigned int min_len;
1396
1397 if (!Mount(Display_Error))
1398 return false;
1399
Dees_Troy38bd7602012-09-14 13:33:53 -04001400 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001401 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001402 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001403 fp = fopen("/tmp/dfoutput.txt", "rt");
1404 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001405 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001406 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001407 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001408
1409 while (fgets(line, sizeof(line), fp) != NULL)
1410 {
1411 unsigned long blocks, used, available;
1412 char device[64];
1413 char tmpString[64];
1414
1415 if (strncmp(line, "Filesystem", 10) == 0)
1416 continue;
1417 if (strlen(line) < min_len) {
1418 include_block = 0;
1419 continue;
1420 }
1421 if (include_block) {
1422 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1423 } else {
1424 // The device block string is so long that the df information is on the next line
1425 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001426 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001427 while (tmpString[space_count] == 32)
1428 space_count++;
1429 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1430 }
1431
1432 // Adjust block size to byte size
1433 Size = blocks * 1024ULL;
1434 Used = used * 1024ULL;
1435 Free = available * 1024ULL;
1436 Backup_Size = Used;
1437 }
1438 fclose(fp);
1439 return true;
1440}
1441
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001442unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001443 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001444
1445 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001446}
1447
Dees_Troy5bf43922012-09-07 16:07:55 -04001448bool TWPartition::Find_Partition_Size(void) {
1449 FILE* fp;
1450 char line[512];
1451 string tmpdevice;
1452
igoriok87e3d932013-01-31 21:03:53 +02001453 fp = fopen("/proc/dumchar_info", "rt");
1454 if (fp != NULL) {
1455 while (fgets(line, sizeof(line), fp) != NULL)
1456 {
1457 char label[32], device[32];
1458 unsigned long size = 0;
1459
thatd43bf2d2014-09-21 23:13:02 +02001460 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001461
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001462 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001463 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1464 continue;
1465
1466 tmpdevice = "/dev/";
1467 tmpdevice += label;
1468 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1469 Size = size;
1470 fclose(fp);
1471 return true;
1472 }
1473 }
1474 }
1475
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001476 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1477 if (ioctl_size) {
1478 Size = ioctl_size;
1479 return true;
1480 }
1481
Dees_Troy5bf43922012-09-07 16:07:55 -04001482 // In this case, we'll first get the partitions we care about (with labels)
1483 fp = fopen("/proc/partitions", "rt");
1484 if (fp == NULL)
1485 return false;
1486
1487 while (fgets(line, sizeof(line), fp) != NULL)
1488 {
1489 unsigned long major, minor, blocks;
1490 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001491
Dees_Troy63c8df72012-09-10 14:02:05 -04001492 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001493 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1494
1495 tmpdevice = "/dev/block/";
1496 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001497 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001498 // Adjust block size to byte size
1499 Size = blocks * 1024ULL;
1500 fclose(fp);
1501 return true;
1502 }
1503 }
1504 fclose(fp);
1505 return false;
1506}
1507
Dees_Troy5bf43922012-09-07 16:07:55 -04001508bool TWPartition::Is_Mounted(void) {
1509 if (!Can_Be_Mounted)
1510 return false;
1511
1512 struct stat st1, st2;
1513 string test_path;
1514
1515 // Check to see if the mount point directory exists
1516 test_path = Mount_Point + "/.";
1517 if (stat(test_path.c_str(), &st1) != 0) return false;
1518
1519 // Check to see if the directory above the mount point exists
1520 test_path = Mount_Point + "/../.";
1521 if (stat(test_path.c_str(), &st2) != 0) return false;
1522
1523 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1524 int ret = (st1.st_dev != st2.st_dev) ? true : false;
Dees_Troy5bf43922012-09-07 16:07:55 -04001525 return ret;
1526}
1527
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001528bool TWPartition::Is_File_System_Writable(void) {
1529 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1530 return false;
1531
1532 string test_path = Mount_Point + "/.";
1533 return (access(test_path.c_str(), W_OK) == 0);
1534}
1535
Dees_Troy5bf43922012-09-07 16:07:55 -04001536bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001537 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001538 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001539
Dees_Troy5bf43922012-09-07 16:07:55 -04001540 if (Is_Mounted()) {
1541 return true;
1542 } else if (!Can_Be_Mounted) {
1543 return false;
1544 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001545
1546 Find_Actual_Block_Device();
1547
1548 // Check the current file system before mounting
1549 Check_FS_Type();
bigbiffad58e1b2020-07-06 20:24:34 -04001550 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/system/bin/exfat-fuse")) {
1551 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 +00001552 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001553 string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001554 if (TWFunc::Exec_Cmd(cmd, result, false) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001555 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001556 Current_File_System = "vfat";
1557 } else {
1558#ifdef TW_NO_EXFAT_FUSE
1559 UnMount(false);
1560 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1561 // Some kernels let us mount vfat as exfat which doesn't work out too well
1562#else
1563 exfat_mounted = 1;
1564#endif
1565 }
1566 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001567
Captain Throwback47bf7202020-10-06 17:39:39 -04001568 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 -05001569 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001570 string Ntfsmount_Binary = "";
1571
bigbiffad58e1b2020-07-06 20:24:34 -04001572 if (TWFunc::Path_Exists("/system/bin/ntfs-3g"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001573 Ntfsmount_Binary = "ntfs-3g";
bigbiffad58e1b2020-07-06 20:24:34 -04001574 else if (TWFunc::Path_Exists("/system/bin/mount.ntfs"))
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001575 Ntfsmount_Binary = "mount.ntfs";
1576
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001577 if (Mount_Read_Only)
bigbiffad58e1b2020-07-06 20:24:34 -04001578 cmd = "/system/bin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001579 else
bigbiffad58e1b2020-07-06 20:24:34 -04001580 cmd = "/system/bin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001581 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001582
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001583 if (TWFunc::Exec_Cmd(cmd) == 0) {
1584 return true;
1585 } else {
1586 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1587 }
Captain Throwback47bf7202020-10-06 17:39:39 -04001588 } else {
1589 if (Current_File_System == "ntfs" && TWFunc::Path_Exists("/sys/module/tntfs"))
1590 Current_File_System = "tntfs";
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001591 }
1592
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001593 if (Mount_Read_Only)
1594 flags |= MS_RDONLY;
1595
Dees_Troy22042032012-12-18 21:23:08 +00001596 if (Fstab_File_System == "yaffs2") {
1597 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001598 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1599 if (Mount_Read_Only)
1600 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001601 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1602 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1603 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001604 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001605 else
1606 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1607 return false;
1608 } else {
1609 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1610 return true;
1611 }
1612 } else {
1613 struct stat st;
1614 string test_path = Mount_Point;
1615 if (stat(test_path.c_str(), &st) < 0) {
1616 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001617 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001618 else
1619 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1620 return false;
1621 }
1622 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1623 if (new_mode != st.st_mode) {
1624 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1625 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1626 if (Display_Error)
1627 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1628 else
1629 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1630 return false;
1631 }
1632 }
Dees_Troy22042032012-12-18 21:23:08 +00001633 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001634 }
thatc7572eb2015-03-31 18:55:30 +02001635 }
1636
1637 string mount_fs = Current_File_System;
1638 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1639 mount_fs = "texfat";
1640
1641 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001642 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1643 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001644#ifdef TW_NO_EXFAT_FUSE
1645 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001646 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001647 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001648 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001649 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001650 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001651 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001652 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 +00001653 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001654 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001655 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001656#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001657 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001658 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001659 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001660 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1661 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 +00001662 return false;
1663#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001664 }
1665#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001666 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001667
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001668 if (Removable)
1669 Update_Size(Display_Error);
1670
bigbiffcda15882021-12-30 17:01:44 -05001671 if (!Symlink_Mount_Point.empty()) {
bigbiffbe4f46c2021-04-24 11:48:54 -04001672 if (!Bind_Mount(false))
1673 return false;
1674 }
1675 return true;
1676}
1677
1678bool TWPartition::Bind_Mount(bool Display_Error) {
1679 if (TWFunc::Path_Exists(Symlink_Path)) {
1680 if (mount(Symlink_Path.c_str(), Symlink_Mount_Point.c_str(), "", MS_BIND, NULL) < 0) {
1681 return false;
1682 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001683 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001684 return true;
1685}
1686
1687bool TWPartition::UnMount(bool Display_Error) {
1688 if (Is_Mounted()) {
1689 int never_unmount_system;
1690
1691 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001692 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001693 return true; // Never unmount system if you're not supposed to unmount it
1694
Matt Mowera8e6d832017-02-14 20:20:59 -06001695 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001696 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001697
Dees_Troy38bd7602012-09-14 13:33:53 -04001698 if (!Symlink_Mount_Point.empty())
1699 umount(Symlink_Mount_Point.c_str());
1700
Dees_Troyb05ddee2013-01-28 20:24:50 +00001701 umount(Mount_Point.c_str());
1702 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001703 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001704 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001705 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001706 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001707 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001708 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001709 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001710 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001711 } else {
1712 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001713 }
1714}
1715
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001716bool TWPartition::ReMount(bool Display_Error) {
1717 if (UnMount(Display_Error))
1718 return Mount(Display_Error);
1719 return false;
1720}
1721
1722bool TWPartition::ReMount_RW(bool Display_Error) {
1723 // No need to remount if already mounted rw
1724 if (Is_File_System_Writable())