blob: beb4a81dbffc4463c4edb1ee9f5503ce08d55ff5 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04002 Copyright 2013 to 2017 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>
22#include <sys/stat.h>
23#include <sys/vfs.h>
Dees_Troy5bf43922012-09-07 16:07:55 -040024#include <sys/mount.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040025#include <unistd.h>
Dees_Troy51127312012-09-08 13:08:49 -040026#include <dirent.h>
thatf54e5392016-01-29 22:04:43 +010027#include <libgen.h>
bigbiffce8f83c2015-12-12 18:30:21 -050028#include <zlib.h>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050029#include <iostream>
30#include <sstream>
Ethan Yonker66a19492015-12-10 10:19:45 -060031#include <sys/param.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060032#include <fcntl.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040033
Ethan Yonker007de982018-08-31 14:23:16 -050034#include "cutils/properties.h"
bigbiff7b4c7a62015-01-01 19:44:14 -050035#include "libblkid/include/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040036#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000037#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040038#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040039#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040040#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050041#include "twrpTar.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060042#include "exclude.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050043#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060044#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050045#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050046#include "adbbu/libtwadbbu.hpp"
Ethan Yonker98661c12018-10-17 08:39:28 -050047#ifdef TW_INCLUDE_CRYPTO
48 #include "crypto/fde/cryptfs.h"
49 #ifdef TW_INCLUDE_FBE
50 #include "crypto/ext4crypt/Decrypt.h"
51 #endif
52#else
53 #define CRYPT_FOOTER_OFFSET 0x4000
54#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040055extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040056 #include "mtdutils/mtdutils.h"
57 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000058#ifdef USE_EXT4
Ethan Yonker8373cfe2017-09-08 06:50:54 -050059 // #include "make_ext4fs.h" TODO need ifdef for android8
60 #include <ext4_utils/make_ext4fs.h>
Dees_Troya95f55c2013-08-17 13:14:43 +000061#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060062#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker66a19492015-12-10 10:19:45 -060063 #include "gpt/gpt.h"
Ethan Yonker71413f42014-02-26 13:36:08 -060064#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040065}
Matt Mower87413642017-01-17 21:14:46 -060066#include <selinux/selinux.h>
Ethan Yonkerf27497f2014-02-09 11:48:33 -060067#include <selinux/label.h>
Dees Troy4159aed2014-02-28 17:24:43 +000068#ifdef HAVE_CAPABILITIES
69#include <sys/capability.h>
70#include <sys/xattr.h>
71#include <linux/xattr.h>
72#endif
HashBanged974bb2016-01-30 14:20:09 -050073#include <sparse_format.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060074#include "progresstracking.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040075
bigbiff bigbiff9c754052013-01-09 09:09:08 -050076using namespace std;
77
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060078static 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
79
Dees_Troya95f55c2013-08-17 13:14:43 +000080extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050081extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000082
Hashcode62bd9e02013-11-19 21:59:42 -080083struct flag_list {
84 const char *name;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060085 unsigned long flag;
Hashcode62bd9e02013-11-19 21:59:42 -080086};
87
Matt Mower4ab42b12016-04-21 13:52:18 -050088const struct flag_list mount_flags[] = {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060089 { "noatime", MS_NOATIME },
90 { "noexec", MS_NOEXEC },
91 { "nosuid", MS_NOSUID },
92 { "nodev", MS_NODEV },
93 { "nodiratime", MS_NODIRATIME },
94 { "ro", MS_RDONLY },
95 { "rw", 0 },
96 { "remount", MS_REMOUNT },
97 { "bind", MS_BIND },
98 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +000099#ifdef MS_UNBINDABLE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600100 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000101#endif
102#ifdef MS_PRIVATE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600103 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000104#endif
105#ifdef MS_SLAVE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600106 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000107#endif
108#ifdef MS_SHARED
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600109 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000110#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600111 { "sync", MS_SYNCHRONOUS },
112 { 0, 0 },
113};
114
115const char *ignored_mount_items[] = {
116 "defaults=",
117 "errors=",
Ethan Yonker93382822018-11-01 15:25:31 -0500118 "latemount",
119 "sysfs_path=",
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600120 NULL
Hashcode62bd9e02013-11-19 21:59:42 -0800121};
122
Matt Mower2416a502016-04-12 19:54:46 -0500123enum TW_FSTAB_FLAGS {
124 TWFLAG_DEFAULTS, // Retain position
125 TWFLAG_ANDSEC,
126 TWFLAG_BACKUP,
127 TWFLAG_BACKUPNAME,
128 TWFLAG_BLOCKSIZE,
129 TWFLAG_CANBEWIPED,
130 TWFLAG_CANENCRYPTBACKUP,
131 TWFLAG_DISPLAY,
132 TWFLAG_ENCRYPTABLE,
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500133 TWFLAG_FILEENCRYPTION,
Matt Mower2416a502016-04-12 19:54:46 -0500134 TWFLAG_FLASHIMG,
135 TWFLAG_FORCEENCRYPT,
136 TWFLAG_FSFLAGS,
137 TWFLAG_IGNOREBLKID,
138 TWFLAG_LENGTH,
139 TWFLAG_MOUNTTODECRYPT,
140 TWFLAG_REMOVABLE,
141 TWFLAG_RETAINLAYOUTVERSION,
142 TWFLAG_SETTINGSSTORAGE,
143 TWFLAG_STORAGE,
144 TWFLAG_STORAGENAME,
145 TWFLAG_SUBPARTITIONOF,
146 TWFLAG_SYMLINK,
147 TWFLAG_USERDATAENCRYPTBACKUP,
148 TWFLAG_USERMRF,
149 TWFLAG_WIPEDURINGFACTORYRESET,
150 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600151 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600152 TWFLAG_WAIT,
153 TWFLAG_VERIFY,
154 TWFLAG_CHECK,
155 TWFLAG_ALTDEVICE,
156 TWFLAG_NOTRIM,
157 TWFLAG_VOLDMANAGED,
158 TWFLAG_FORMATTABLE,
159 TWFLAG_RESIZE,
Ethan Yonker93382822018-11-01 15:25:31 -0500160 TWFLAG_KEYDIRECTORY,
Matt Mower2416a502016-04-12 19:54:46 -0500161};
162
163/* Flags without a trailing '=' are considered dual format flags and can be
164 * written as either 'flagname' or 'flagname=', where the character following
165 * the '=' is Y,y,1 for true and false otherwise.
166 */
167const struct flag_list tw_flags[] = {
168 { "andsec", TWFLAG_ANDSEC },
169 { "backup", TWFLAG_BACKUP },
170 { "backupname=", TWFLAG_BACKUPNAME },
171 { "blocksize=", TWFLAG_BLOCKSIZE },
172 { "canbewiped", TWFLAG_CANBEWIPED },
173 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
174 { "defaults", TWFLAG_DEFAULTS },
175 { "display=", TWFLAG_DISPLAY },
176 { "encryptable=", TWFLAG_ENCRYPTABLE },
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500177 { "fileencryption=", TWFLAG_FILEENCRYPTION },
Matt Mower2416a502016-04-12 19:54:46 -0500178 { "flashimg", TWFLAG_FLASHIMG },
179 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
180 { "fsflags=", TWFLAG_FSFLAGS },
181 { "ignoreblkid", TWFLAG_IGNOREBLKID },
182 { "length=", TWFLAG_LENGTH },
183 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
184 { "removable", TWFLAG_REMOVABLE },
185 { "retainlayoutversion", TWFLAG_RETAINLAYOUTVERSION },
186 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
187 { "storage", TWFLAG_STORAGE },
188 { "storagename=", TWFLAG_STORAGENAME },
189 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
190 { "symlink=", TWFLAG_SYMLINK },
191 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
192 { "usermrf", TWFLAG_USERMRF },
193 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
194 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600195 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600196 { "wait", TWFLAG_WAIT },
197 { "verify", TWFLAG_VERIFY },
198 { "check", TWFLAG_CHECK },
199 { "altdevice", TWFLAG_ALTDEVICE },
200 { "notrim", TWFLAG_NOTRIM },
201 { "voldmanaged=", TWFLAG_VOLDMANAGED },
202 { "formattable", TWFLAG_FORMATTABLE },
203 { "resize", TWFLAG_RESIZE },
Ethan Yonker93382822018-11-01 15:25:31 -0500204 { "keydirectory=", TWFLAG_KEYDIRECTORY },
Matt Mower2416a502016-04-12 19:54:46 -0500205 { 0, 0 },
206};
207
that9e0593e2014-10-08 00:01:24 +0200208TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400209 Can_Be_Mounted = false;
210 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500211 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200212 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400213 Wipe_During_Factory_Reset = false;
214 Wipe_Available_in_GUI = false;
215 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400216 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400217 SubPartition_Of = "";
218 Symlink_Path = "";
219 Symlink_Mount_Point = "";
220 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400221 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600222 Wildcard_Block_Device = false;
223 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400224 Actual_Block_Device = "";
225 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400226 Alternate_Block_Device = "";
227 Removable = false;
228 Is_Present = false;
229 Length = 0;
230 Size = 0;
231 Used = 0;
232 Free = 0;
233 Backup_Size = 0;
234 Can_Be_Encrypted = false;
235 Is_Encrypted = false;
236 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600237 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600238 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400239 Decrypted_Block_Device = "";
240 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500241 Backup_Display_Name = "";
242 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400243 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400244 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400245 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500246 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000247 Can_Encrypt_Backup = false;
248 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400249 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400250 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400251 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500252 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400253 Storage_Path = "";
254 Current_File_System = "";
255 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800256 Mount_Flags = 0;
257 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400258 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000259 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +0000260 Retain_Layout_Version = false;
dianlujitao4879b372018-12-03 18:45:47 +0800261 Crypto_Key_Location = "";
Ethan Yonker726a0202014-12-16 20:01:38 -0600262 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600263 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500264 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600265 Is_Adopted_Storage = false;
266 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600267 SlotSelect = false;
Ethan Yonker93382822018-11-01 15:25:31 -0500268 Key_Directory = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400269}
270
271TWPartition::~TWPartition(void) {
272 // Do nothing
273}
274
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600275bool 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 -0500276 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500277 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400278 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500279 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500280 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600281 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
282 TWPartition *additional_entry = NULL;
283 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400284
Matt Mower2b2dd152016-04-26 11:24:08 -0500285 strlcpy(full_line, fstab_line, sizeof(full_line));
Dees_Troy51127312012-09-08 13:08:49 -0400286 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500287 if (full_line[index] == 34)
288 skip = !skip;
289 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400290 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400291 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600292 if (line_len < 10)
293 return false; // There can't possibly be a valid fstab line that is less than 10 chars
294 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
295 fstab_version = 2;
296 block_device_index = 0;
297 mount_point_index = 1;
298 fs_index = 2;
299 }
300
301 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400302 while (index < line_len) {
303 while (index < line_len && full_line[index] == '\0')
304 index++;
305 if (index >= line_len)
306 continue;
307 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600308 if (item_index == mount_point_index) {
309 Mount_Point = ptr;
310 if (fstab_version == 2) {
311 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
312 if (additional_entry) {
313 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
314 }
315 }
316 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
317 Backup_Path = Mount_Point;
318 Storage_Path = Mount_Point;
319 Display_Name = ptr + 1;
320 Backup_Display_Name = Display_Name;
321 Storage_Name = Display_Name;
322 item_index++;
323 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400324 // File System
325 Fstab_File_System = ptr;
326 Current_File_System = ptr;
327 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600328 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400329 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400330 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400331 MTD_Name = ptr;
332 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400333 } else if (Fstab_File_System == "bml") {
334 if (Mount_Point == "/boot")
335 MTD_Name = "boot";
336 else if (Mount_Point == "/recovery")
337 MTD_Name = "recovery";
338 Primary_Block_Device = ptr;
339 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000340 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 -0400341 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400342 if (Display_Error)
Matt Mower2b2dd152016-04-26 11:24:08 -0500343 LOGERR("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400344 else
Matt Mower2b2dd152016-04-26 11:24:08 -0500345 LOGINFO("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
Matt Mower72c87ce2016-04-26 14:34:56 -0500346 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400347 } else {
348 Primary_Block_Device = ptr;
349 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400350 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400351 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600352 } else if (item_index > 2) {
353 if (fstab_version == 2) {
354 if (item_index == 3) {
355 Process_FS_Flags(ptr);
356 if (additional_entry) {
357 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
358 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
359 }
360 } else {
361 strlcpy(twflags, ptr, sizeof(twflags));
362 }
363 item_index++;
364 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400365 // Alternate Block Device
366 Alternate_Block_Device = ptr;
367 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
368 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
369 // Partition length
370 ptr += 7;
371 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400372 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
373 // Custom flags, save for later so that new values aren't overwritten by defaults
374 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500375 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400376 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
377 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400378 } else {
379 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500380 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400381 }
382 }
383 while (index < line_len && full_line[index] != '\0')
384 index++;
385 }
386
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600387 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
388 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
389 it = twrp_flags->find(Mount_Point);
390 if (it != twrp_flags->end()) {
391 if (!it->second.Primary_Block_Device.empty()) {
392 Primary_Block_Device = it->second.Primary_Block_Device;
393 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
394 }
395 if (!it->second.Alternate_Block_Device.empty()) {
396 Alternate_Block_Device = it->second.Alternate_Block_Device;
397 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
398 }
399 }
400 }
401
402 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
403 Sysfs_Entry = Primary_Block_Device;
404 Primary_Block_Device = "";
405 Is_Storage = true;
406 Removable = true;
407 Wipe_Available_in_GUI = true;
408 Wildcard_Block_Device = true;
409 }
410 if (Primary_Block_Device.find("*") != string::npos)
411 Wildcard_Block_Device = true;
412
413 if (Mount_Point == "auto") {
414 Mount_Point = "/auto";
415 char autoi[5];
416 sprintf(autoi, "%i", auto_index);
417 Mount_Point += autoi;
418 Backup_Path = Mount_Point;
419 Storage_Path = Mount_Point;
420 auto_index++;
421 Setup_File_System(Display_Error);
422 Display_Name = "Storage";
423 Backup_Display_Name = Display_Name;
424 Storage_Name = Display_Name;
425 Can_Be_Backed_Up = false;
426 Wipe_Available_in_GUI = true;
427 Is_Storage = true;
428 Removable = true;
429 Wipe_Available_in_GUI = true;
430 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400431 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000432 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400433 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000434 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500435 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400436 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400437 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400438 Setup_File_System(Display_Error);
Captain Throwback9d6feb52018-07-27 10:05:24 -0400439 if (Mount_Point == PartitionManager.Get_Android_Root_Path()) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400440 Display_Name = "System";
Dees_Troya13d74f2013-03-24 08:54:55 -0500441 Backup_Display_Name = Display_Name;
442 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400443 Wipe_Available_in_GUI = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500444 Can_Be_Backed_Up = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500445 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400446 } else if (Mount_Point == "/data") {
447 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500448 Backup_Display_Name = Display_Name;
449 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400450 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400451 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500452 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000453 Can_Encrypt_Backup = true;
454 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400455 } else if (Mount_Point == "/cache") {
456 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500457 Backup_Display_Name = Display_Name;
458 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400459 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400460 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500461 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400462 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400463 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400464 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500465 Backup_Display_Name = Display_Name;
466 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400467 Is_SubPartition = true;
468 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400469 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500470 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000471 Can_Encrypt_Backup = true;
472 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400473 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400474 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400475 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500476 Backup_Display_Name = Display_Name;
477 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400478 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400479 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500480 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000481 Can_Encrypt_Backup = true;
482 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400483 } else if (Mount_Point == "/boot") {
484 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500485 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400486 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500487 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500488 } else if (Mount_Point == "/vendor") {
489 Display_Name = "Vendor";
490 Backup_Display_Name = Display_Name;
491 Storage_Name = Display_Name;
492 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400493 }
494#ifdef TW_EXTERNAL_STORAGE_PATH
495 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
496 Is_Storage = true;
497 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400498 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500499 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400500#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000501 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400502 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400503 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500504 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400505#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000506 }
Dees_Troy8170a922012-09-18 15:40:25 -0400507#ifdef TW_INTERNAL_STORAGE_PATH
508 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
509 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500510 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400511 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500512 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400513 }
514#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000515 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400516 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500517 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500518 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400519 }
520#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400521 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400522 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600523 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500524 if (Mount_Point == "/boot") {
525 Display_Name = "Boot";
526 Backup_Display_Name = Display_Name;
527 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600528 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500529 } else if (Mount_Point == "/recovery") {
530 Display_Name = "Recovery";
531 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600532 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500533 } else if (Mount_Point == "/system_image") {
534 Display_Name = "System Image";
535 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500536 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500537 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500538 } else if (Mount_Point == "/vendor_image") {
539 Display_Name = "Vendor Image";
540 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500541 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500542 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500543 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400544 }
545
Matt Mower2416a502016-04-12 19:54:46 -0500546 // Process TWRP fstab flags
547 if (strlen(twflags) > 0) {
548 string Prev_Display_Name = Display_Name;
549 string Prev_Storage_Name = Storage_Name;
550 string Prev_Backup_Display_Name = Backup_Display_Name;
551 Display_Name = "";
552 Storage_Name = "";
553 Backup_Display_Name = "";
554
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600555 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
556 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500557
558 bool has_display_name = !Display_Name.empty();
559 bool has_storage_name = !Storage_Name.empty();
560 bool has_backup_name = !Backup_Display_Name.empty();
561 if (!has_display_name) Display_Name = Prev_Display_Name;
562 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
563 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
564
565 if (has_display_name && !has_storage_name)
566 Storage_Name = Display_Name;
567 if (!has_display_name && has_storage_name)
568 Display_Name = Storage_Name;
569 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
570 Backup_Display_Name = Display_Name;
571 if (!has_display_name && has_backup_name)
572 Display_Name = Backup_Display_Name;
573 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600574
575 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
576 it = twrp_flags->find(Mount_Point);
577 if (it != twrp_flags->end()) {
578 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
579 int skip = 0;
580 string Flags = it->second.Flags;
581 strcpy(twrpflags, Flags.c_str());
582 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
583 skip += strlen("flags=");
584 char* flagptr = twrpflags;
585 flagptr += skip;
586 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
587 }
588 }
nkk7198fc3992017-12-16 16:26:42 +0200589
590 if (Mount_Point == "/persist" && Can_Be_Mounted) {
591 bool mounted = Is_Mounted();
592 if (mounted || Mount(false)) {
593 // Read the backup settings file
594 DataManager::LoadPersistValues();
595 TWFunc::Fixup_Time_On_Boot("/persist/time/");
596 if (!mounted)
597 UnMount(false);
598 }
599 }
600
Dees_Troy51127312012-09-08 13:08:49 -0400601 return true;
602}
603
Matt Mower72c87ce2016-04-26 14:34:56 -0500604void TWPartition::Partition_Post_Processing(bool Display_Error) {
605 if (Mount_Point == "/data")
606 Setup_Data_Partition(Display_Error);
607 else if (Mount_Point == "/cache")
608 Setup_Cache_Partition(Display_Error);
609}
610
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600611void TWPartition::ExcludeAll(const string& path) {
612 backup_exclusions.add_absolute_dir(path);
613 wipe_exclusions.add_absolute_dir(path);
614}
615
Matt Mower72c87ce2016-04-26 14:34:56 -0500616void TWPartition::Setup_Data_Partition(bool Display_Error) {
617 if (Mount_Point != "/data")
618 return;
619
620 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
621 UnMount(false);
622
623#ifdef TW_INCLUDE_CRYPTO
624 if (datamedia)
625 Setup_Data_Media();
626 Can_Be_Encrypted = true;
627 char crypto_blkdev[255];
628 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
629 if (strcmp(crypto_blkdev, "error") != 0) {
630 DataManager::SetValue(TW_IS_DECRYPTED, 1);
631 Is_Encrypted = true;
632 Is_Decrypted = true;
Ethan Yonker93382822018-11-01 15:25:31 -0500633 if (Key_Directory.empty())
634 Is_FBE = false;
635 else
636 Is_FBE = true;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600637 DataManager::SetValue(TW_IS_FBE, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500638 Decrypted_Block_Device = crypto_blkdev;
639 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
640 } else if (!Mount(false)) {
641 if (Is_Present) {
Ethan Yonker93382822018-11-01 15:25:31 -0500642 if (Key_Directory.empty()) {
643 set_partition_data(Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(), Fstab_File_System.c_str());
644 if (cryptfs_check_footer() == 0) {
645 Is_Encrypted = true;
646 Is_Decrypted = false;
647 Can_Be_Mounted = false;
648 Current_File_System = "emmc";
649 Setup_Image();
650 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
651 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
652 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
653 DataManager::SetValue("tw_crypto_display", "");
654 } else {
655 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
656 }
657 } else {
Matt Mower72c87ce2016-04-26 14:34:56 -0500658 Is_Encrypted = true;
659 Is_Decrypted = false;
Matt Mower72c87ce2016-04-26 14:34:56 -0500660 }
Ethan Yonker93382822018-11-01 15:25:31 -0500661 } else if (Key_Directory.empty()) {
Matt Mower72c87ce2016-04-26 14:34:56 -0500662 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
663 }
664 } else {
mauronofrio9bf73352019-11-23 22:27:34 +0100665
666 if (!Decrypt_FBE_DE()) {
667 LOGINFO("Trying wrapped key.\n");
668 property_set("fbe.data.wrappedkey", "true");
669 if (!Decrypt_FBE_DE()) {
Mauronofrio Matarrese6d5d08a2019-12-03 14:25:25 +0100670 LOGINFO("Unable to decrypt device\n");
mauronofrio9bf73352019-11-23 22:27:34 +0100671 }
672 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500673 }
674 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
675 Setup_Data_Media();
676 Recreate_Media_Folder();
677 }
678#else
679 if (datamedia) {
680 Setup_Data_Media();
681 Recreate_Media_Folder();
682 }
683#endif
684}
685
Ethan Yonker93382822018-11-01 15:25:31 -0500686bool TWPartition::Decrypt_FBE_DE() {
687if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
688 LOGINFO("File Based Encryption is present\n");
689#ifdef TW_INCLUDE_FBE
690 ExcludeAll(Mount_Point + "/convert_fbe");
691 ExcludeAll(Mount_Point + "/unencrypted");
692 //ExcludeAll(Mount_Point + "/system/users/0"); // we WILL need to retain some of this if multiple users are present or we just need to delete more folders for the extra users somewhere else
693 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
694 //ExcludeAll(Mount_Point + "/system_ce");
695 //ExcludeAll(Mount_Point + "/system_de");
696 //ExcludeAll(Mount_Point + "/misc_ce");
697 //ExcludeAll(Mount_Point + "/misc_de");
698 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
699 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
700 ExcludeAll(Mount_Point + "/system/locksettings.db");
701 //ExcludeAll(Mount_Point + "/system/locksettings.db-shm"); // don't seem to need this one, but the other 2 are needed
702 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
703 //ExcludeAll(Mount_Point + "/user_de");
704 //ExcludeAll(Mount_Point + "/misc/profiles/cur/0"); // might be important later
705 ExcludeAll(Mount_Point + "/misc/gatekeeper");
706 ExcludeAll(Mount_Point + "/misc/keystore");
707 ExcludeAll(Mount_Point + "/drm/kek.dat");
708 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt pixel 2
709 int retry_count = 3;
710 while (!Decrypt_DE() && --retry_count)
711 usleep(2000);
712 if (retry_count > 0) {
713 property_set("ro.crypto.state", "encrypted");
714 Is_Encrypted = true;
715 Is_Decrypted = false;
716 Is_FBE = true;
717 DataManager::SetValue(TW_IS_FBE, 1);
718 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
719 string filename;
720 int pwd_type = Get_Password_Type(0, filename);
721 if (pwd_type < 0) {
722 LOGERR("This TWRP does not have synthetic password decrypt support\n");
723 pwd_type = 0; // default password
724 }
725 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
726 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
727 DataManager::SetValue("tw_crypto_display", "");
728 return true;
729 }
730#else
731 LOGERR("FBE found but FBE support not present in TWRP\n");
732#endif
733 }
734 return false;
735}
736
Matt Mower72c87ce2016-04-26 14:34:56 -0500737void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
738 if (Mount_Point != "/cache")
739 return;
740
741 if (!Mount(true))
742 return;
743
744 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
745 LOGINFO("Recreating /cache/recovery folder\n");
746 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
747 LOGERR("Could not create /cache/recovery\n");
748 }
749}
750
Matt Mower4ab42b12016-04-21 13:52:18 -0500751void TWPartition::Process_FS_Flags(const char *str) {
752 char *options = strdup(str);
753 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800754
Matt Mower4ab42b12016-04-21 13:52:18 -0500755 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800756
Matt Mower4ab42b12016-04-21 13:52:18 -0500757 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600758 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
759 char *equals = strstr(ptr, "=");
760 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500761
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600762 if (!equals)
763 name_len = strlen(ptr);
764 else
765 name_len = equals - ptr;
766
767 // There are some flags that we want to ignore in TWRP
768 bool found_match = false;
769 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
770 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
771 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800772 break;
773 }
774 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600775 if (found_match)
776 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800777
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600778 // mount_flags are never postfixed by '='
779 if (!equals) {
780 const struct flag_list* mount_flag = mount_flags;
781 for (; mount_flag->name; mount_flag++) {
782 if (strcmp(ptr, mount_flag->name) == 0) {
783 if (mount_flag->flag == MS_RDONLY)
784 Mount_Read_Only = true;
785 else
786 Mount_Flags |= (unsigned)mount_flag->flag;
787 found_match = true;
788 break;
789 }
790 }
791 if (found_match)
792 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500793 }
794
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600795 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
796 if (!Mount_Options.empty())
797 Mount_Options += ",";
798 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500799 }
800 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800801}
802
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600803void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
804 partition_fs_flags_struct flags;
805 flags.File_System = local_File_System;
806 flags.Mount_Flags = local_Mount_Flags;
807 flags.Mount_Options = local_Mount_Options;
808 fs_flags.push_back(flags);
809}
810
Matt Mower2416a502016-04-12 19:54:46 -0500811void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
812 switch (flag) {
813 case TWFLAG_ANDSEC:
814 Has_Android_Secure = val;
815 break;
816 case TWFLAG_BACKUP:
817 Can_Be_Backed_Up = val;
818 break;
819 case TWFLAG_BACKUPNAME:
820 Backup_Display_Name = str;
821 break;
822 case TWFLAG_BLOCKSIZE:
823 Format_Block_Size = (unsigned long)(atol(str));
824 break;
825 case TWFLAG_CANBEWIPED:
826 Can_Be_Wiped = val;
827 break;
828 case TWFLAG_CANENCRYPTBACKUP:
829 Can_Encrypt_Backup = val;
830 break;
831 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600832 case TWFLAG_WAIT:
833 case TWFLAG_VERIFY:
834 case TWFLAG_CHECK:
835 case TWFLAG_NOTRIM:
836 case TWFLAG_VOLDMANAGED:
837 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500838 // Do nothing
839 break;
840 case TWFLAG_DISPLAY:
841 Display_Name = str;
842 break;
843 case TWFLAG_ENCRYPTABLE:
844 case TWFLAG_FORCEENCRYPT:
845 Crypto_Key_Location = str;
846 break;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500847 case TWFLAG_FILEENCRYPTION:
848 // This flag isn't used by TWRP but is needed in 9.0 FBE decrypt
849 // fileencryption=ice:aes-256-heh
850 {
851 std::string FBE = str;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500852 size_t colon_loc = FBE.find(":");
853 if (colon_loc == std::string::npos) {
Ethan Yonker93382822018-11-01 15:25:31 -0500854 property_set("fbe.contents", FBE.c_str());
855 property_set("fbe.filenames", "");
856 LOGINFO("FBE contents '%s', filenames ''\n", FBE.c_str());
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500857 break;
858 }
Ethan Yonker93382822018-11-01 15:25:31 -0500859 std::string FBE_contents, FBE_filenames;
Ethan Yonkere9afc3d2018-08-30 15:16:27 -0500860 FBE_contents = FBE.substr(0, colon_loc);
861 FBE_filenames = FBE.substr(colon_loc + 1);
862 property_set("fbe.contents", FBE_contents.c_str());
863 property_set("fbe.filenames", FBE_filenames.c_str());
864 LOGINFO("FBE contents '%s', filenames '%s'\n", FBE_contents.c_str(), FBE_filenames.c_str());
865 }
866 break;
Matt Mower2416a502016-04-12 19:54:46 -0500867 case TWFLAG_FLASHIMG:
868 Can_Flash_Img = val;
869 break;
870 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500871 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500872 break;
873 case TWFLAG_IGNOREBLKID:
874 Ignore_Blkid = val;
875 break;
876 case TWFLAG_LENGTH:
877 Length = atoi(str);
878 break;
879 case TWFLAG_MOUNTTODECRYPT:
880 Mount_To_Decrypt = val;
881 break;
882 case TWFLAG_REMOVABLE:
883 Removable = val;
884 break;
885 case TWFLAG_RETAINLAYOUTVERSION:
886 Retain_Layout_Version = val;
887 break;
888 case TWFLAG_SETTINGSSTORAGE:
889 Is_Settings_Storage = val;
890 if (Is_Settings_Storage)
891 Is_Storage = true;
892 break;
893 case TWFLAG_STORAGE:
894 Is_Storage = val;
895 break;
896 case TWFLAG_STORAGENAME:
897 Storage_Name = str;
898 break;
899 case TWFLAG_SUBPARTITIONOF:
900 Is_SubPartition = true;
901 SubPartition_Of = str;
902 break;
903 case TWFLAG_SYMLINK:
904 Symlink_Path = str;
905 break;
906 case TWFLAG_USERDATAENCRYPTBACKUP:
907 Use_Userdata_Encryption = val;
908 if (Use_Userdata_Encryption)
909 Can_Encrypt_Backup = true;
910 break;
911 case TWFLAG_USERMRF:
912 Use_Rm_Rf = val;
913 break;
914 case TWFLAG_WIPEDURINGFACTORYRESET:
915 Wipe_During_Factory_Reset = val;
916 if (Wipe_During_Factory_Reset) {
917 Can_Be_Wiped = true;
918 Wipe_Available_in_GUI = true;
919 }
920 break;
921 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600922 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -0500923 Wipe_Available_in_GUI = val;
924 if (Wipe_Available_in_GUI)
925 Can_Be_Wiped = true;
926 break;
Ethan Yonker1b190162016-12-05 15:25:19 -0600927 case TWFLAG_SLOTSELECT:
928 SlotSelect = true;
929 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600930 case TWFLAG_ALTDEVICE:
931 Alternate_Block_Device = str;
932 break;
Ethan Yonker93382822018-11-01 15:25:31 -0500933 case TWFLAG_KEYDIRECTORY:
934 Key_Directory = str;
Matt Mower2416a502016-04-12 19:54:46 -0500935 default:
936 // Should not get here
937 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
938 break;
939 }
940}
Dees_Troy51127312012-09-08 13:08:49 -0400941
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600942void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -0500943 char separator[2] = {'\n', 0};
944 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600945 char source_separator = ';';
946
947 if (fstab_ver == 2)
948 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -0500949
950 // Semicolons within double-quotes are not forbidden, so replace
951 // only the semicolons intended as separators with '\n' for strtok
952 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
953 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -0500954 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600955 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -0500956 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -0400957 }
958
Matt Mower2416a502016-04-12 19:54:46 -0500959 // Avoid issues with potentially nested strtok by using strtok_r
960 ptr = strtok_r(flags, separator, &savep);
961 while (ptr) {
962 int ptr_len = strlen(ptr);
963 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -0800964
Matt Mower2416a502016-04-12 19:54:46 -0500965 for (; tw_flag->name; tw_flag++) {
966 int flag_len = strlen(tw_flag->name);
967
968 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
969 bool flag_val = false;
970
971 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
972 && ptr[flag_len] != '=') {
973 // Handle flags with same starting string
974 // (e.g. backup and backupname)
975 continue;
976 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
977 // Handle flags with dual format: Part 1
978 // (e.g. backup and backup=y. backup=y handled here)
979 ptr += flag_len + 1;
980 TWFunc::Strip_Quotes(ptr);
981 // Skip flags with empty argument
982 // (e.g. backup=)
983 if (strlen(ptr) == 0) {
984 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
985 break;
986 }
987 flag_val = strchr("yY1", *ptr) != NULL;
988 } else if (ptr_len == flag_len
989 && (tw_flag->name)[flag_len-1] == '=') {
990 // Skip flags missing argument after =
991 // (e.g. backupname=)
992 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
993 break;
994 } else if (ptr_len > flag_len
995 && (tw_flag->name)[flag_len-1] == '=') {
996 // Handle arguments to flags
997 // (e.g. backupname="My Stuff")
998 ptr += flag_len;
999 TWFunc::Strip_Quotes(ptr);
1000 // Skip flags with empty argument
1001 // (e.g. backupname="")
1002 if (strlen(ptr) == 0) {
1003 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
1004 break;
1005 }
1006 } else if (ptr_len == flag_len) {
1007 // Handle flags with dual format: Part 2
1008 // (e.g. backup and backup=y. backup handled here)
1009 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001010 } else {
Matt Mower2416a502016-04-12 19:54:46 -05001011 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
1012 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001013 }
Matt Mower2416a502016-04-12 19:54:46 -05001014
1015 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
1016 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -06001017 }
Matt Mower2416a502016-04-12 19:54:46 -05001018 }
1019 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -04001020 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001021 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001022 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001023 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -04001024 }
Matt Mower2416a502016-04-12 19:54:46 -05001025 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -04001026 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001027}
1028
Dees_Troy5bf43922012-09-07 16:07:55 -04001029bool TWPartition::Is_File_System(string File_System) {
1030 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -04001031 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001032 File_System == "ext4" ||
1033 File_System == "vfat" ||
1034 File_System == "ntfs" ||
1035 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -05001036 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +00001037 File_System == "f2fs" ||
Erfan Abdib859e912019-02-05 18:18:46 +02001038 File_System == "squashfs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -04001039 File_System == "auto")
1040 return true;
1041 else
1042 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001043}
1044
Dees_Troy5bf43922012-09-07 16:07:55 -04001045bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001046 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001047 return true;
1048 else
1049 return false;
1050}
1051
Dees_Troy51127312012-09-08 13:08:49 -04001052bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001053 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1054 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001055 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001056 if (mkdir(Path.c_str(), 0777) == -1) {
1057 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001058 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001059 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001060 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001061 return false;
1062 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001063 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001064 return true;
1065 }
1066 }
1067 return true;
1068}
1069
Dees_Troy5bf43922012-09-07 16:07:55 -04001070void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001071 Can_Be_Mounted = true;
1072 Can_Be_Wiped = true;
1073
Dees_Troy5bf43922012-09-07 16:07:55 -04001074 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001075 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -04001076 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1077 Backup_Name = Display_Name;
bigbiffce8f83c2015-12-12 18:30:21 -05001078 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001079}
1080
Ethan Yonker1b190162016-12-05 15:25:19 -06001081void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001082 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1083 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001084 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001085 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001086 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001087 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001088 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001089 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 -04001090}
1091
Dees_Troye58d5262012-09-21 12:27:57 -04001092void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001093 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001094 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001095 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001096 Has_Android_Secure = true;
1097 Symlink_Path = Mount_Point + "/.android_secure";
1098 Symlink_Mount_Point = "/and-sec";
1099 Backup_Path = Symlink_Mount_Point;
1100 Make_Dir("/and-sec", true);
1101 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001102 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001103}
1104
that9e0593e2014-10-08 00:01:24 +02001105void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001106 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001107 if (Storage_Name.empty() || Storage_Name == "Data")
1108 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001109 Has_Data_Media = true;
1110 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001111 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001112 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001113 if (Mount_Point == "/data") {
1114 Is_Settings_Storage = true;
1115 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1116 Make_Dir("/emmc", false);
1117 Symlink_Mount_Point = "/emmc";
1118 } else {
1119 Make_Dir("/sdcard", false);
1120 Symlink_Mount_Point = "/sdcard";
1121 }
1122 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1123 Storage_Path = Mount_Point + "/media/0";
1124 Symlink_Path = Storage_Path;
1125 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1126 UnMount(true);
1127 }
1128 DataManager::SetValue("tw_has_internal", 1);
1129 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001130 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
Darth90864aa52020-01-14 20:58:16 +00001131 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
Ethan Yonker6355b562017-05-01 09:42:17 -05001132 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001133 ExcludeAll(Mount_Point + "/.layout_version");
1134 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001135 } else {
Ethan Yonker66a19492015-12-10 10:19:45 -06001136 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1137 Storage_Path = Mount_Point + "/media/0";
1138 Symlink_Path = Storage_Path;
1139 UnMount(true);
1140 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001141 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001142 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001143}
1144
Dees_Troy5bf43922012-09-07 16:07:55 -04001145void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001146 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001147
1148 strcpy(device, Block.c_str());
1149 memset(realDevice, 0, sizeof(realDevice));
1150 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1151 {
1152 strcpy(device, realDevice);
1153 memset(realDevice, 0, sizeof(realDevice));
1154 }
1155
1156 if (device[0] != '/') {
1157 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001158 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001159 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001160 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001161 return;
Dees_Troy51a0e822012-09-05 15:24:24 -04001162 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001163 Block = device;
1164 return;
1165 }
1166}
1167
Kjell Braden3126a112016-06-19 16:58:15 +00001168bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001169 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001170 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001171 int retry_count = 5;
1172 while (retry_count > 0 && !Mount(false)) {
1173 usleep(500000);
1174 retry_count--;
1175 }
Kjell Braden3126a112016-06-19 16:58:15 +00001176 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001177 }
Kjell Braden3126a112016-06-19 16:58:15 +00001178 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001179}
1180
Dees_Troy38bd7602012-09-14 13:33:53 -04001181bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1182 FILE *fp = NULL;
1183 char line[255];
1184
1185 fp = fopen("/proc/mtd", "rt");
1186 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001187 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001188 return false;
1189 }
1190
1191 while (fgets(line, sizeof(line), fp) != NULL)
1192 {
1193 char device[32], label[32];
1194 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001195 int deviceId;
1196
1197 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1198
1199 // Skip header and blank lines
1200 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1201 continue;
1202
1203 // Strip off the trailing " from the label
1204 label[strlen(label)-1] = '\0';
1205
1206 if (strcmp(label, MTD_Name.c_str()) == 0) {
1207 // We found our device
1208 // Strip off the trailing : from the device
1209 device[strlen(device)-1] = '\0';
1210 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1211 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1212 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001213 fclose(fp);
1214 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001215 }
1216 }
1217 }
1218 fclose(fp);
1219
1220 return false;
1221}
1222
Dees_Troy51127312012-09-08 13:08:49 -04001223bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1224 struct statfs st;
1225 string Local_Path = Mount_Point + "/.";
1226
1227 if (!Mount(Display_Error))
1228 return false;
1229
1230 if (statfs(Local_Path.c_str(), &st) != 0) {
1231 if (!Removable) {
1232 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001233 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001234 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001235 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001236 }
1237 return false;
1238 }
1239 Size = (st.f_blocks * st.f_bsize);
1240 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1241 Free = (st.f_bfree * st.f_bsize);
1242 Backup_Size = Used;
1243 return true;
1244}
1245
1246bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001247 FILE* fp;
1248 char command[255], line[512];
1249 int include_block = 1;
1250 unsigned int min_len;
1251
1252 if (!Mount(Display_Error))
1253 return false;
1254
Dees_Troy38bd7602012-09-14 13:33:53 -04001255 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001256 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001257 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001258 fp = fopen("/tmp/dfoutput.txt", "rt");
1259 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001260 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001261 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001262 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001263
1264 while (fgets(line, sizeof(line), fp) != NULL)
1265 {
1266 unsigned long blocks, used, available;
1267 char device[64];
1268 char tmpString[64];
1269
1270 if (strncmp(line, "Filesystem", 10) == 0)
1271 continue;
1272 if (strlen(line) < min_len) {
1273 include_block = 0;
1274 continue;
1275 }
1276 if (include_block) {
1277 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1278 } else {
1279 // The device block string is so long that the df information is on the next line
1280 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001281 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001282 while (tmpString[space_count] == 32)
1283 space_count++;
1284 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1285 }
1286
1287 // Adjust block size to byte size
1288 Size = blocks * 1024ULL;
1289 Used = used * 1024ULL;
1290 Free = available * 1024ULL;
1291 Backup_Size = Used;
1292 }
1293 fclose(fp);
1294 return true;
1295}
1296
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001297unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001298 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001299
1300 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001301}
1302
Dees_Troy5bf43922012-09-07 16:07:55 -04001303bool TWPartition::Find_Partition_Size(void) {
1304 FILE* fp;
1305 char line[512];
1306 string tmpdevice;
1307
igoriok87e3d932013-01-31 21:03:53 +02001308 fp = fopen("/proc/dumchar_info", "rt");
1309 if (fp != NULL) {
1310 while (fgets(line, sizeof(line), fp) != NULL)
1311 {
1312 char label[32], device[32];
1313 unsigned long size = 0;
1314
thatd43bf2d2014-09-21 23:13:02 +02001315 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001316
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001317 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001318 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1319 continue;
1320
1321 tmpdevice = "/dev/";
1322 tmpdevice += label;
1323 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1324 Size = size;
1325 fclose(fp);
1326 return true;
1327 }
1328 }
1329 }
1330
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001331 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1332 if (ioctl_size) {
1333 Size = ioctl_size;
1334 return true;
1335 }
1336
Dees_Troy5bf43922012-09-07 16:07:55 -04001337 // In this case, we'll first get the partitions we care about (with labels)
1338 fp = fopen("/proc/partitions", "rt");
1339 if (fp == NULL)
1340 return false;
1341
1342 while (fgets(line, sizeof(line), fp) != NULL)
1343 {
1344 unsigned long major, minor, blocks;
1345 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001346
Dees_Troy63c8df72012-09-10 14:02:05 -04001347 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001348 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1349
1350 tmpdevice = "/dev/block/";
1351 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001352 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001353 // Adjust block size to byte size
1354 Size = blocks * 1024ULL;
1355 fclose(fp);
1356 return true;
1357 }
1358 }
1359 fclose(fp);
1360 return false;
1361}
1362
Dees_Troy5bf43922012-09-07 16:07:55 -04001363bool TWPartition::Is_Mounted(void) {
1364 if (!Can_Be_Mounted)
1365 return false;
1366
1367 struct stat st1, st2;
1368 string test_path;
1369
1370 // Check to see if the mount point directory exists
1371 test_path = Mount_Point + "/.";
1372 if (stat(test_path.c_str(), &st1) != 0) return false;
1373
1374 // Check to see if the directory above the mount point exists
1375 test_path = Mount_Point + "/../.";
1376 if (stat(test_path.c_str(), &st2) != 0) return false;
1377
1378 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1379 int ret = (st1.st_dev != st2.st_dev) ? true : false;
1380
1381 return ret;
1382}
1383
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001384bool TWPartition::Is_File_System_Writable(void) {
1385 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1386 return false;
1387
1388 string test_path = Mount_Point + "/.";
1389 return (access(test_path.c_str(), W_OK) == 0);
1390}
1391
Dees_Troy5bf43922012-09-07 16:07:55 -04001392bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001393 int exfat_mounted = 0;
Martin Dünkelmann6d843782018-12-27 23:40:28 +01001394 unsigned int flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001395
Dees_Troy5bf43922012-09-07 16:07:55 -04001396 if (Is_Mounted()) {
1397 return true;
1398 } else if (!Can_Be_Mounted) {
1399 return false;
1400 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001401
1402 Find_Actual_Block_Device();
1403
1404 // Check the current file system before mounting
1405 Check_FS_Type();
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001406 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
Dees_Troye34c1332013-02-06 19:13:00 +00001407 string cmd = "/sbin/exfat-fuse -o big_writes,max_read=131072,max_write=131072 " + Actual_Block_Device + " " + Mount_Point;
Dees_Troy2673cec2013-04-02 20:22:16 +00001408 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001409 string result;
1410 if (TWFunc::Exec_Cmd(cmd, result) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001411 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001412 Current_File_System = "vfat";
1413 } else {
1414#ifdef TW_NO_EXFAT_FUSE
1415 UnMount(false);
1416 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1417 // Some kernels let us mount vfat as exfat which doesn't work out too well
1418#else
1419 exfat_mounted = 1;
1420#endif
1421 }
1422 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001423
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001424 if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfs-3g") || TWFunc::Path_Exists("/sbin/mount.ntfs"))) {
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001425 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001426 string Ntfsmount_Binary = "";
1427
1428 if (TWFunc::Path_Exists("/sbin/ntfs-3g"))
1429 Ntfsmount_Binary = "ntfs-3g";
1430 else if (TWFunc::Path_Exists("/sbin/mount.ntfs"))
1431 Ntfsmount_Binary = "mount.ntfs";
1432
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001433 if (Mount_Read_Only)
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001434 cmd = "/sbin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001435 else
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001436 cmd = "/sbin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001437 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001438
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001439 if (TWFunc::Exec_Cmd(cmd) == 0) {
1440 return true;
1441 } else {
1442 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1443 }
1444 }
1445
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001446 if (Mount_Read_Only)
1447 flags |= MS_RDONLY;
1448
Dees_Troy22042032012-12-18 21:23:08 +00001449 if (Fstab_File_System == "yaffs2") {
1450 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001451 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1452 if (Mount_Read_Only)
1453 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001454 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1455 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1456 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001457 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001458 else
1459 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1460 return false;
1461 } else {
1462 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1463 return true;
1464 }
1465 } else {
1466 struct stat st;
1467 string test_path = Mount_Point;
1468 if (stat(test_path.c_str(), &st) < 0) {
1469 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001470 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001471 else
1472 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1473 return false;
1474 }
1475 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1476 if (new_mode != st.st_mode) {
1477 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1478 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1479 if (Display_Error)
1480 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1481 else
1482 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1483 return false;
1484 }
1485 }
Dees_Troy22042032012-12-18 21:23:08 +00001486 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001487 }
thatc7572eb2015-03-31 18:55:30 +02001488 }
1489
1490 string mount_fs = Current_File_System;
1491 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1492 mount_fs = "texfat";
1493
1494 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001495 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1496 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001497#ifdef TW_NO_EXFAT_FUSE
1498 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001499 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001500 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001501 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001502 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001503 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001504 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001505 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 +00001506 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001507 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001508 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001509#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001510 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001511 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001512 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001513 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1514 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 +00001515 return false;
1516#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001517 }
1518#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001519 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001520
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001521 if (Removable)
1522 Update_Size(Display_Error);
1523
xiaolu9416f4f2015-06-04 08:22:23 +08001524 if (!Symlink_Mount_Point.empty() && TWFunc::Path_Exists(Symlink_Path)) {
codelover2a3d4ce2015-03-14 20:26:49 +08001525 string Command = "mount -o bind '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
Vojtech Bocek05534202013-09-11 08:11:56 +02001526 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001527 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001528 return true;
1529}
1530
1531bool TWPartition::UnMount(bool Display_Error) {
1532 if (Is_Mounted()) {
1533 int never_unmount_system;
1534
1535 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
Captain Throwback9d6feb52018-07-27 10:05:24 -04001536 if (never_unmount_system == 1 && Mount_Point == PartitionManager.Get_Android_Root_Path())
Dees_Troy5bf43922012-09-07 16:07:55 -04001537 return true; // Never unmount system if you're not supposed to unmount it
1538
Matt Mowera8e6d832017-02-14 20:20:59 -06001539 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001540 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001541
Dees_Troy38bd7602012-09-14 13:33:53 -04001542 if (!Symlink_Mount_Point.empty())
1543 umount(Symlink_Mount_Point.c_str());
1544
Dees_Troyb05ddee2013-01-28 20:24:50 +00001545 umount(Mount_Point.c_str());
1546 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001547 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001548 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001549 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001550 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001551 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001552 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001553 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001554 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001555 } else {
1556 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001557 }
1558}
1559
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001560bool TWPartition::ReMount(bool Display_Error) {
1561 if (UnMount(Display_Error))
1562 return Mount(Display_Error);
1563 return false;
1564}
1565
1566bool TWPartition::ReMount_RW(bool Display_Error) {
1567 // No need to remount if already mounted rw
1568 if (Is_File_System_Writable())
1569 return true;
1570
1571 bool ro = Mount_Read_Only;
1572 int flags = Mount_Flags;
1573
1574 Mount_Read_Only = false;
1575 Mount_Flags &= ~MS_RDONLY;
1576
1577 bool ret = ReMount(Display_Error);
1578
1579 Mount_Read_Only = ro;
1580 Mount_Flags = flags;
1581
1582 return ret;
1583}
1584
Gary Peck43acadf2012-11-21 21:19:01 -08001585bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001586 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001587 int check;
1588 string Layout_Filename = Mount_Point + "/.layout_version";
1589
Dees_Troy38bd7602012-09-14 13:33:53 -04001590 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001591 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001592 return false;
1593 }
1594
Dees_Troyc51f1f92012-09-20 15:32:13 -04001595 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001596 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001597
Dees_Troy16c2b312013-01-15 16:51:18 +00001598 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
1599 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
1600 else
1601 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -04001602
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001603 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001604 wiped = Wipe_Data_Without_Wiping_Media();
Ethan Yonker5eac2222014-06-11 12:22:55 -05001605 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001606 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001607 DataManager::GetValue(TW_RM_RF_VAR, check);
1608
Hashcodedabfd492013-08-29 22:45:30 -07001609 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001610 wiped = Wipe_RMRF();
1611 else if (New_File_System == "ext4")
1612 wiped = Wipe_EXT4();
1613 else if (New_File_System == "ext2" || New_File_System == "ext3")
dianlujitao4879b372018-12-03 18:45:47 +08001614 wiped = Wipe_EXTFS(New_File_System);
Dees_Troy16c2b312013-01-15 16:51:18 +00001615 else if (New_File_System == "vfat")
1616 wiped = Wipe_FAT();
1617 else if (New_File_System == "exfat")
1618 wiped = Wipe_EXFAT();
1619 else if (New_File_System == "yaffs2")
1620 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001621 else if (New_File_System == "f2fs")
1622 wiped = Wipe_F2FS();
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001623 else if (New_File_System == "ntfs")
1624 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001625 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001626 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 +00001627 unlink("/.layout_version");
1628 return false;
1629 }
1630 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001631 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001632
Gary Pecke8bc5d72012-12-21 06:45:25 -08001633 if (wiped) {
Dees_Troy1c1ac442013-01-17 21:42:14 +00001634 if (Mount_Point == "/cache")
1635 DataManager::Output_Version();
1636
Dees_Troy16c2b312013-01-15 16:51:18 +00001637 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
1638 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
1639
1640 if (update_crypt) {
1641 Setup_File_System(false);
1642 if (Is_Encrypted && !Is_Decrypted) {
1643 // just wiped an encrypted partition back to its unencrypted state
1644 Is_Encrypted = false;
1645 Is_Decrypted = false;
1646 Decrypted_Block_Device = "";
1647 if (Mount_Point == "/data") {
1648 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1649 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1650 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001651 }
1652 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001653
Ethan Yonker66a19492015-12-10 10:19:45 -06001654 if (Has_Data_Media && recreate_media) {
Ethan Yonker5eac2222014-06-11 12:22:55 -05001655 Recreate_Media_Folder();
1656 }
Matt Mower209c9632016-01-20 12:08:35 -06001657 if (Is_Storage && Mount(false))
1658 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001659 }
Matt Mower209c9632016-01-20 12:08:35 -06001660
Gary Pecke8bc5d72012-12-21 06:45:25 -08001661 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001662}
1663
Gary Peck43acadf2012-11-21 21:19:01 -08001664bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001665 if (Is_File_System(Current_File_System))
1666 return Wipe(Current_File_System);
1667 else
1668 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001669}
1670
Dees_Troye58d5262012-09-21 12:27:57 -04001671bool TWPartition::Wipe_AndSec(void) {
1672 if (!Has_Android_Secure)
1673 return false;
1674
Dees_Troye58d5262012-09-21 12:27:57 -04001675 if (!Mount(true))
1676 return false;
1677
Ethan Yonker74db1572015-10-28 12:44:49 -05001678 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001679 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001680 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001681}
1682
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001683bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001684 if (Mount_Read_Only)
1685 return false;
Matt Mower18794c82015-11-11 16:22:45 -06001686 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/sbin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001687 return true;
1688 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/e2fsck"))
1689 return true;
1690 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/fsck.exfat"))
1691 return true;
1692 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/sbin/fsck.f2fs"))
1693 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001694 else if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfsfix") || TWFunc::Path_Exists("/sbin/fsck.ntfs")))
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001695 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001696 return false;
1697}
1698
1699bool TWPartition::Repair() {
1700 string command;
1701
1702 if (Current_File_System == "vfat") {
Matt Mower18794c82015-11-11 16:22:45 -06001703 if (!TWFunc::Path_Exists("/sbin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001704 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001705 return false;
1706 }
1707 if (!UnMount(true))
1708 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001709 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001710 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06001711 command = "/sbin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001712 LOGINFO("Repair command: %s\n", command.c_str());
1713 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001714 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001715 return true;
1716 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001717 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001718 return false;
1719 }
1720 }
1721 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1722 if (!TWFunc::Path_Exists("/sbin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001723 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001724 return false;
1725 }
1726 if (!UnMount(true))
1727 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001728 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001729 Find_Actual_Block_Device();
Ethan Yonkera2719152015-05-28 09:44:41 -05001730 command = "/sbin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001731 LOGINFO("Repair command: %s\n", command.c_str());
1732 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001733 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001734 return true;
1735 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001736 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001737 return false;
1738 }
1739 }
1740 if (Current_File_System == "exfat") {
1741 if (!TWFunc::Path_Exists("/sbin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001742 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001743 return false;
1744 }
1745 if (!UnMount(true))
1746 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001747 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001748 Find_Actual_Block_Device();
1749 command = "/sbin/fsck.exfat " + Actual_Block_Device;
1750 LOGINFO("Repair command: %s\n", command.c_str());
1751 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001752 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001753 return true;
1754 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001755 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001756 return false;
1757 }
1758 }
1759 if (Current_File_System == "f2fs") {
1760 if (!TWFunc::Path_Exists("/sbin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001761 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001762 return false;
1763 }
1764 if (!UnMount(true))
1765 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001766 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001767 Find_Actual_Block_Device();
1768 command = "/sbin/fsck.f2fs " + Actual_Block_Device;
1769 LOGINFO("Repair command: %s\n", command.c_str());
1770 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001771 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001772 return true;
1773 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001774 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001775 return false;
1776 }
1777 }
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001778 if (Current_File_System == "ntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001779 string Ntfsfix_Binary;
1780 if (TWFunc::Path_Exists("/sbin/ntfsfix"))
1781 Ntfsfix_Binary = "ntfsfix";
1782 else if (TWFunc::Path_Exists("/sbin/fsck.ntfs"))
1783 Ntfsfix_Binary = "fsck.ntfs";
1784 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001785 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001786 return false;
1787 }
1788 if (!UnMount(true))
1789 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001790 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001791 Find_Actual_Block_Device();
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001792 command = "/sbin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001793 LOGINFO("Repair command: %s\n", command.c_str());
1794 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001795 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001796 return true;
1797 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001798 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001799 return false;
1800 }
1801 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001802 return false;
1803}
1804
Ethan Yonkera2719152015-05-28 09:44:41 -05001805bool TWPartition::Can_Resize() {
1806 if (Mount_Read_Only)
1807 return false;
1808 if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/resize2fs"))
1809 return true;
1810 return false;
1811}
1812
1813bool TWPartition::Resize() {
1814 string command;
1815
1816 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1817 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001818 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1819 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001820 return false;
1821 }
1822 if (!TWFunc::Path_Exists("/sbin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001823 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1824 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001825 return false;
1826 }
1827 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001828 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001829 if (!Repair())
1830 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001831 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001832 Find_Actual_Block_Device();
1833 command = "/sbin/resize2fs " + Actual_Block_Device;
1834 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001835 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1836 if (Actual_Size == 0)
1837 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001838
Ethan Yonkera2719152015-05-28 09:44:41 -05001839 unsigned long long Block_Count;
1840 if (Length < 0) {
1841 // Reduce overall size by this length
1842 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1843 } else {
1844 // This is the size, not a size reduction
1845 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1846 }
1847 char temp[256];
1848 sprintf(temp, "%llu", Block_Count);
1849 command += " ";
1850 command += temp;
1851 command += "K";
1852 }
1853 LOGINFO("Resize command: %s\n", command.c_str());
1854 if (TWFunc::Exec_Cmd(command) == 0) {
1855 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001856 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001857 return true;
1858 } else {
1859 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001860 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001861 return false;
1862 }
1863 }
1864 return false;
1865}
1866
bigbiffce8f83c2015-12-12 18:30:21 -05001867bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
1868 if (Backup_Method == BM_FILES)
1869 return Backup_Tar(part_settings, tar_fork_pid);
1870 else if (Backup_Method == BM_DD)
1871 return Backup_Image(part_settings);
1872 else if (Backup_Method == BM_FLASH_UTILS)
1873 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00001874 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001875 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001876}
1877
bigbiffce8f83c2015-12-12 18:30:21 -05001878bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06001879 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05001880 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001881
bigbiffce8f83c2015-12-12 18:30:21 -05001882 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001883
1884 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05001885 return Restore_Tar(part_settings);
1886 else if (Is_Image(Restore_File_System))
1887 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001888
1889 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1890 return false;
1891}
1892
bigbiffce8f83c2015-12-12 18:30:21 -05001893string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001894 size_t first_period, second_period;
1895 string Restore_File_System;
1896
Gary Peck43acadf2012-11-21 21:19:01 -08001897 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001898 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08001899 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001900 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001901 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001902 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001903 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08001904 second_period = Restore_File_System.find(".");
1905 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001906 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001907 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001908 }
1909 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06001910 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001911 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04001912}
1913
1914string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05001915 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04001916 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05001917 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04001918 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05001919 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04001920 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05001921 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04001922 return "flash_utils";
1923 else
1924 return "undefined";
1925 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04001926}
1927
1928bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001929 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001930 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04001931 return 1;
1932}
1933
1934bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001935 bool Save_Data_Media = Has_Data_Media;
Ethan Yonker93382822018-11-01 15:25:31 -05001936 bool ret = false;
1937 BasePartition* base_partition = make_partition();
1938
1939 if (!base_partition->PreWipeEncryption())
1940 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04001941
dianlujitao4879b372018-12-03 18:45:47 +08001942 Find_Actual_Block_Device();
1943 if (!Is_Present) {
1944 LOGINFO("Block device not present, cannot format %s.\n", Display_Name.c_str());
1945 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
1946 return false;
1947 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001948 if (!UnMount(true))
Ethan Yonker93382822018-11-01 15:25:31 -05001949 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04001950
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001951#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker1b190162016-12-05 15:25:19 -06001952 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Matt Mower2b18a532015-02-20 16:58:05 -06001953 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001954 LOGERR("Error deleting crypto block device, continuing anyway.\n");
1955 }
1956 }
1957#endif
dianlujitao4879b372018-12-03 18:45:47 +08001958 Has_Data_Media = false;
Ethan Yonker93382822018-11-01 15:25:31 -05001959 Decrypted_Block_Device = "";
Dees_Troy74fb2e92013-04-15 14:35:47 +00001960 Is_Decrypted = false;
1961 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001962 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001963 Has_Data_Media = Save_Data_Media;
1964 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
1965 Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001966 if (Mount(false))
1967 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001968 }
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001969 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05001970#ifndef TW_OEM_BUILD
Ethan Yonker74db1572015-10-28 12:44:49 -05001971 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 -05001972#endif
Ethan Yonker93382822018-11-01 15:25:31 -05001973 ret = true;
1974 if (!Key_Directory.empty())
1975 ret = PartitionManager.Wipe_By_Path(Key_Directory);
1976 if (ret)
1977 ret = base_partition->PostWipeEncryption();
1978 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04001979 } else {
1980 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05001981 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06001982 if (Has_Data_Media && Mount(false))
1983 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -05001984 goto exit;
Dees_Troy38bd7602012-09-14 13:33:53 -04001985 }
Ethan Yonker93382822018-11-01 15:25:31 -05001986exit:
1987 delete base_partition;
1988 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04001989}
1990
1991void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001992 const char* type;
1993 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04001994
Dees_Troy68cab492012-12-12 19:29:35 +00001995 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1996 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001997
Dees_Troy38bd7602012-09-14 13:33:53 -04001998 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001999 if (!Is_Present)
2000 return;
Dees_Troy51127312012-09-08 13:08:49 -04002001
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002002 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
2003 if (blkid_do_fullprobe(pr)) {
2004 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002005 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002006 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04002007 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002008
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002009 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002010 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00002011 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002012 return;
2013 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002014
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05002015 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002016 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002017 if (fs_flags.size() > 1) {
2018 std::vector<partition_fs_flags_struct>::iterator iter;
2019 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2020
2021 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2022 if (iter->File_System == Current_File_System) {
2023 found = iter;
2024 break;
2025 }
2026 }
2027 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2028 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2029 Mount_Flags = found->Mount_Flags;
2030 Mount_Options = found->Mount_Options;
2031 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2032 }
2033 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002034}
2035
dianlujitao4879b372018-12-03 18:45:47 +08002036bool TWPartition::Wipe_EXTFS(string File_System) {
2037#if PLATFORM_SDK_VERSION < 28
2038 if (!TWFunc::Path_Exists("/sbin/mke2fs"))
2039#else
2040 if (!TWFunc::Path_Exists("/sbin/mke2fs") || !TWFunc::Path_Exists("/sbin/e2fsdroid"))
2041#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002042 return Wipe_RMRF();
2043
dianlujitao4879b372018-12-03 18:45:47 +08002044 int ret;
2045 bool NeedPreserveFooter = true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002046
Ethan Yonker25f20c12014-10-14 09:04:43 -05002047 Find_Actual_Block_Device();
2048 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002049 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2050 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05002051 return false;
2052 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002053 if (!UnMount(true))
2054 return false;
2055
dianlujitao4879b372018-12-03 18:45:47 +08002056 /**
2057 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2058 * so there's no need to preserve footer.
2059 */
2060 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2061 Crypto_Key_Location != "footer") {
2062 NeedPreserveFooter = false;
2063 }
2064
2065 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2066 if (!dev_sz)
2067 return false;
2068
2069 if (NeedPreserveFooter)
2070 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2071
Dees Troy9a4d7402019-03-21 14:17:28 -04002072 char dout[16];
2073 sprintf(dout, "%llu", dev_sz / 4096);
2074
2075 //string size_str =to_string(dev_sz / 4096);
2076 string size_str = dout;
dianlujitao4879b372018-12-03 18:45:47 +08002077 string Command;
2078
2079 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
2080
2081 // Execute mke2fs to create empty ext4 filesystem
2082 Command = "mke2fs -t " + File_System + " -b 4096 " + Actual_Block_Device + " " + size_str;
2083 LOGINFO("mke2fs command: %s\n", Command.c_str());
2084 ret = TWFunc::Exec_Cmd(Command);
2085 if (ret) {
2086 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2087 return false;
2088 }
2089
2090 if (TWFunc::Path_Exists("/sbin/e2fsdroid")) {
dianlujitao3cf05a52019-05-15 15:33:27 +08002091 const string& File_Contexts_Entry = (Mount_Point == "/system_root" ? "/" : Mount_Point);
2092 char *secontext = NULL;
2093 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, File_Contexts_Entry.c_str(), S_IFDIR) < 0) {
2094 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2095 } else {
2096 // Execute e2fsdroid to initialize selinux context
2097 Command = "e2fsdroid -e -S /file_contexts -a " + File_Contexts_Entry + " " + Actual_Block_Device;
2098 LOGINFO("e2fsdroid command: %s\n", Command.c_str());
2099 ret = TWFunc::Exec_Cmd(Command);
2100 if (ret) {
2101 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2102 return false;
2103 }
dianlujitao4879b372018-12-03 18:45:47 +08002104 }
2105 } else {
2106 LOGINFO("e2fsdroid not present\n");
2107 }
2108
2109 if (NeedPreserveFooter)
2110 Wipe_Crypto_Key();
2111 Current_File_System = File_System;
2112 Recreate_AndSec_Folder();
2113 gui_msg("done=Done.");
2114 return true;
2115}
2116
2117bool TWPartition::Wipe_EXT4() {
2118#ifdef USE_EXT4
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002119 int ret;
dianlujitao4879b372018-12-03 18:45:47 +08002120 bool NeedPreserveFooter = true;
2121
2122 Find_Actual_Block_Device();
2123 if (!Is_Present) {
2124 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2125 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2126 return false;
2127 }
2128 if (!UnMount(true))
2129 return false;
2130
2131 /**
2132 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2133 * so there's no need to preserve footer.
2134 */
2135 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2136 Crypto_Key_Location != "footer") {
2137 NeedPreserveFooter = false;
2138 }
2139
2140 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2141 if (!dev_sz)
2142 return false;
2143
2144 if (NeedPreserveFooter)
2145 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2146
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002147 char *secontext = NULL;
2148
Greg Wallace4b44fef2015-12-29 15:33:24 -05002149 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002150
Dees Troy99c8dbf2014-03-10 16:53:58 +00002151 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002152 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
dianlujitao4879b372018-12-03 18:45:47 +08002153 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), NULL);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002154 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002155 ret = make_ext4fs(Actual_Block_Device.c_str(), dev_sz, Mount_Point.c_str(), selinux_handle);
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002156 }
2157 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002158 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002159 return false;
2160 } else {
dianlujitao4879b372018-12-03 18:45:47 +08002161 if (NeedPreserveFooter)
2162 Wipe_Crypto_Key();
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002163 string sedir = Mount_Point + "/lost+found";
2164 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2165 rmdir(sedir.c_str());
2166 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002167 return true;
2168 }
2169#else
dianlujitao4879b372018-12-03 18:45:47 +08002170 return Wipe_EXTFS("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002171#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04002172}
2173
2174bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002175 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002176
Matt Mower18794c82015-11-11 16:22:45 -06002177 if (TWFunc::Path_Exists("/sbin/mkfs.fat")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002178 if (!UnMount(true))
2179 return false;
2180
Greg Wallace4b44fef2015-12-29 15:33:24 -05002181 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002182 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002183 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002184 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002185 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002186 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002187 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002188 return true;
2189 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002190 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002191 return false;
2192 }
2193 return true;
2194 }
2195 else
2196 return Wipe_RMRF();
2197
2198 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002199}
2200
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002201bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002202 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002203
2204 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
2205 if (!UnMount(true))
2206 return false;
2207
Greg Wallace4b44fef2015-12-29 15:33:24 -05002208 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002209 Find_Actual_Block_Device();
2210 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002211 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002212 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002213 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002214 return true;
2215 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002216 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002217 return false;
2218 }
2219 return true;
2220 }
2221 return false;
2222}
2223
Dees_Troy38bd7602012-09-14 13:33:53 -04002224bool TWPartition::Wipe_MTD() {
2225 if (!UnMount(true))
2226 return false;
2227
Greg Wallace4b44fef2015-12-29 15:33:24 -05002228 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002229
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002230 mtd_scan_partitions();
2231 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2232 if (mtd == NULL) {
2233 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2234 return false;
2235 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002236
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002237 MtdWriteContext* ctx = mtd_write_partition(mtd);
2238 if (ctx == NULL) {
2239 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2240 return false;
2241 }
2242 if (mtd_erase_blocks(ctx, -1) == -1) {
2243 mtd_write_close(ctx);
2244 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2245 return false;
2246 }
2247 if (mtd_write_close(ctx) != 0) {
2248 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2249 return false;
2250 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002251 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002252 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002253 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002254 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002255}
2256
2257bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002258 if (!Mount(true))
2259 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002260 // This is the only wipe that leaves the partition mounted, so we
2261 // must manually remove the partition from MTP if it is a storage
2262 // partition.
2263 if (Is_Storage)
2264 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002265
Ethan Yonker74db1572015-10-28 12:44:49 -05002266 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002267 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002268 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002269 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002270}
2271
Dees_Troye5017042013-08-29 16:38:55 +00002272bool TWPartition::Wipe_F2FS() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002273 string command;
Dees_Troye5017042013-08-29 16:38:55 +00002274
2275 if (TWFunc::Path_Exists("/sbin/mkfs.f2fs")) {
dianlujitao4879b372018-12-03 18:45:47 +08002276 bool NeedPreserveFooter = true;
2277
2278 Find_Actual_Block_Device();
2279 if (!Is_Present) {
2280 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
2281 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2282 return false;
2283 }
Dees_Troye5017042013-08-29 16:38:55 +00002284 if (!UnMount(true))
2285 return false;
2286
dianlujitao4879b372018-12-03 18:45:47 +08002287 /**
2288 * On decrypted devices, IOCTL_Get_Block_Size calculates size on device mapper,
2289 * so there's no need to preserve footer.
2290 */
2291 if ((Is_Decrypted && !Decrypted_Block_Device.empty()) ||
2292 Crypto_Key_Location != "footer") {
2293 NeedPreserveFooter = false;
dhacker29a3fa75f2015-01-17 19:42:33 -05002294 }
dianlujitao4879b372018-12-03 18:45:47 +08002295
dianlujitao4879b372018-12-03 18:45:47 +08002296 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.f2fs"));
Ethan Yonker7e941582019-03-22 08:18:21 -05002297 // First determine if we have the old mkfs.f2fs that uses "-r reserved_bytes"
2298 // or the new mkfs.f2fs that expects the number of sectors as the optional last argument
2299 // Note: some 7.1 trees have the old and some have the new.
2300 command = "mkfs.f2fs | grep \"reserved\" > /tmp/f2fsversiontest";
2301 TWFunc::Exec_Cmd(command, false); // no help argument so printing usage exits with an error code
2302 if (!TWFunc::Path_Exists("/tmp/f2fsversiontest")) {
2303 LOGINFO("Error determining mkfs.f2fs version\n");
2304 return false;
2305 }
2306 if (TWFunc::Get_File_Size("/tmp/f2fsversiontest") <= 0) {
2307 LOGINFO("Using newer mkfs.f2fs\n");
2308 unsigned long long dev_sz = TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
2309 if (!dev_sz)
2310 return false;
2311
2312 if (NeedPreserveFooter)
2313 Length < 0 ? dev_sz += Length : dev_sz -= CRYPT_FOOTER_OFFSET;
2314
2315 char dev_sz_str[48];
2316 sprintf(dev_sz_str, "%llu", (dev_sz / 4096));
2317 command = "mkfs.f2fs -d1 -f -O encrypt -O quota -O verity -w 4096 " + Actual_Block_Device + " " + dev_sz_str;
2318 if (TWFunc::Path_Exists("/sbin/sload.f2fs")) {
2319 command += " && sload.f2fs -t /data " + Actual_Block_Device;
2320 }
2321 } else {
2322 LOGINFO("Using older mkfs.f2fs\n");
2323 command = "mkfs.f2fs -t 0";
2324 if (NeedPreserveFooter) {
2325 // Only use length if we're not decrypted
2326 char len[32];
2327 int mod_length = Length;
2328 if (Length < 0)
2329 mod_length *= -1;
2330 sprintf(len, "%i", mod_length);
2331 command += " -r ";
2332 command += len;
2333 }
2334 command += " " + Actual_Block_Device;
dianlujitao4879b372018-12-03 18:45:47 +08002335 }
2336 LOGINFO("mkfs.f2fs command: %s\n", command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002337 if (TWFunc::Exec_Cmd(command) == 0) {
dianlujitao4879b372018-12-03 18:45:47 +08002338 if (NeedPreserveFooter)
2339 Wipe_Crypto_Key();
Dees_Troye5017042013-08-29 16:38:55 +00002340 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002341 gui_msg("done=Done.");
Dees_Troye5017042013-08-29 16:38:55 +00002342 return true;
2343 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002344 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troye5017042013-08-29 16:38:55 +00002345 return false;
2346 }
2347 return true;
2348 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002349 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002350 return Wipe_RMRF();
2351 }
2352 return false;
2353}
2354
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002355bool TWPartition::Wipe_NTFS() {
2356 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002357 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002358
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002359 if (TWFunc::Path_Exists("/sbin/mkntfs"))
2360 Ntfsmake_Binary = "mkntfs";
2361 else if (TWFunc::Path_Exists("/sbin/mkfs.ntfs"))
2362 Ntfsmake_Binary = "mkfs.ntfs";
2363 else
2364 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002365
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002366 if (!UnMount(true))
2367 return false;
2368
Greg Wallace4b44fef2015-12-29 15:33:24 -05002369 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002370 Find_Actual_Block_Device();
2371 command = "/sbin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
2372 if (TWFunc::Exec_Cmd(command) == 0) {
2373 Recreate_AndSec_Folder();
2374 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002375 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002376 } else {
2377 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2378 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002379 }
2380 return false;
2381}
2382
Dees_Troy51a0e822012-09-05 15:24:24 -04002383bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002384#ifdef TW_OEM_BUILD
2385 // In an OEM Build we want to do a full format
2386 return Wipe_Encryption();
2387#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002388 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002389
Dees_Troy38bd7602012-09-14 13:33:53 -04002390 if (!Mount(true))
2391 return false;
2392
Ethan Yonker74db1572015-10-28 12:44:49 -05002393 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002394 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2395 if (ret)
2396 gui_msg("done=Done.");
2397 return ret;
2398#endif // ifdef TW_OEM_BUILD
2399}
2400
2401bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2402 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002403
2404 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002405 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002406 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002407 struct dirent* de;
2408 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002409 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002410
Ethan Yonker66a19492015-12-10 10:19:45 -06002411 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002412 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002413 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002414 LOGINFO("skipped '%s'\n", dir.c_str());
2415 continue;
2416 }
Dees_Troyce675462013-01-09 19:48:21 +00002417 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002418 dir.append("/");
2419 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2420 closedir(d);
2421 return false;
2422 }
2423 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002424 } 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 +03002425 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002426 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002427 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002428 }
2429 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002430
Dees_Troy16b74352012-11-14 22:27:31 +00002431 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002432 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002433 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002434 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002435}
2436
dianlujitao4879b372018-12-03 18:45:47 +08002437void TWPartition::Wipe_Crypto_Key() {
2438 Find_Actual_Block_Device();
2439 if (Crypto_Key_Location.empty())
2440 return;
2441 else if (Crypto_Key_Location == "footer") {
2442 int fd = open(Actual_Block_Device.c_str(), O_RDWR);
2443 if (fd < 0) {
2444 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
2445 return;
2446 }
2447
2448 unsigned int block_count;
2449 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
2450 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
2451 } else {
2452 int newlen = Length < 0 ? -Length : CRYPT_FOOTER_OFFSET;
2453 off64_t offset = ((off64_t)block_count * 512) - newlen;
2454 if (lseek64(fd, offset, SEEK_SET) == -1) {
2455 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
2456 } else {
2457 void* buffer = malloc(newlen);
2458 if (!buffer) {
2459 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
2460 } else {
2461 memset(buffer, 0, newlen);
2462 int ret = write(fd, buffer, newlen);
2463 if (ret != newlen) {
2464 gui_print_color("warning", "Failed to wipe crypto footer.\n");
2465 } else {
2466 LOGINFO("Successfully wiped crypto footer.\n");
2467 }
2468 free(buffer);
2469 }
2470 }
2471 }
2472 close(fd);
2473 } else {
2474 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
2475 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
2476 TWFunc::Exec_Cmd(Command);
2477 } else {
2478 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
2479 }
2480 }
2481}
2482
bigbiffce8f83c2015-12-12 18:30:21 -05002483bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002484 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002485 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002486
Dees_Troy43d8b002012-09-17 16:00:01 -04002487 if (!Mount(true))
2488 return false;
2489
Ian Macdonalda3b25a32019-06-16 22:39:14 +02002490 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, gui_parse_text("{@backing}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002491 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002492
Ethan Yonker472f5062016-02-25 13:47:30 -06002493 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002494
Dees_Troy83bd4832013-05-04 12:39:56 +00002495#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002496 if (Can_Encrypt_Backup) {
2497 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2498 if (tar.use_encryption) {
2499 if (Use_Userdata_Encryption)
2500 tar.userdata_encryption = tar.use_encryption;
2501 string Password;
2502 DataManager::GetValue("tw_backup_password", Password);
2503 tar.setpassword(Password);
2504 } else {
2505 tar.use_encryption = 0;
2506 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002507 }
2508#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002509
Ethan Yonker472f5062016-02-25 13:47:30 -06002510 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002511 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002512 if (Has_Data_Media)
2513 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));
bigbiffce8f83c2015-12-12 18:30:21 -05002514 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002515 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002516 tar.setdir(Backup_Path);
2517 tar.setfn(Full_FileName);
2518 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002519 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002520 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002521 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002522 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002523 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002524}
2525
bigbiffce8f83c2015-12-12 18:30:21 -05002526bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2527 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002528
Ethan Yonker74db1572015-10-28 12:44:49 -05002529 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2530 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002531
Ethan Yonker472f5062016-02-25 13:47:30 -06002532 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002533
bigbiffce8f83c2015-12-12 18:30:21 -05002534 if (part_settings->adbbackup) {
2535 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002536 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002537 }
2538 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002539 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002540
2541 part_settings->total_restore_size = Backup_Size;
2542
2543 if (part_settings->adbbackup) {
2544 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2545 return false;
2546 }
2547
2548 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002549 return false;
2550
bigbiffce8f83c2015-12-12 18:30:21 -05002551 if (part_settings->adbbackup) {
2552 if (!twadbbu::Write_TWEOF())
2553 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002554 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002555 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002556}
2557
bigbiffce8f83c2015-12-12 18:30:21 -05002558bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2559 unsigned long long RW_Block_Size, Remain = Backup_Size;
2560 int src_fd = -1, dest_fd = -1;
2561 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002562 bool ret = false;
2563 void* buffer = NULL;
2564 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002565 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002566
bigbiffce8f83c2015-12-12 18:30:21 -05002567 if (part_settings->PM_Method == PM_BACKUP) {
2568 srcfn = Actual_Block_Device;
2569 if (part_settings->adbbackup)
2570 destfn = TW_ADB_BACKUP;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002571 else {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002572 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiff bigbiff38b83c12017-12-28 19:58:52 -05002573 }
bigbiffce8f83c2015-12-12 18:30:21 -05002574 }
2575 else {
2576 destfn = Actual_Block_Device;
2577 if (part_settings->adbbackup) {
2578 srcfn = TW_ADB_RESTORE;
2579 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002580 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002581 Remain = TWFunc::Get_File_Size(srcfn);
2582 }
2583 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002584
bigbiffce8f83c2015-12-12 18:30:21 -05002585 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002586 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002587 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002588 return false;
2589 }
bigbiffce8f83c2015-12-12 18:30:21 -05002590
2591 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 -06002592 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002593 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002594 goto exit;
2595 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002596
bigbiffce8f83c2015-12-12 18:30:21 -05002597 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2598
2599 if (part_settings->adbbackup) {
2600 RW_Block_Size = MAX_ADB_READ;
2601 bs = MAX_ADB_READ;
2602 }
2603 else {
2604 RW_Block_Size = 1048576LLU; // 1MB
2605 bs = (ssize_t)(RW_Block_Size);
2606 }
2607
Ethan Yonker472f5062016-02-25 13:47:30 -06002608 buffer = malloc((size_t)bs);
2609 if (!buffer) {
2610 LOGINFO("Raw_Read_Write failed to malloc\n");
2611 goto exit;
2612 }
bigbiffce8f83c2015-12-12 18:30:21 -05002613
2614 if (part_settings->progress)
2615 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2616
Ethan Yonker472f5062016-02-25 13:47:30 -06002617 while (Remain > 0) {
2618 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002619 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002620 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002621 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2622 goto exit;
2623 }
2624 if (write(dest_fd, buffer, bs) != bs) {
2625 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2626 goto exit;
2627 }
2628 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002629 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002630 if (part_settings->progress)
2631 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002632 if (PartitionManager.Check_Backup_Cancel() != 0)
2633 goto exit;
2634 }
bigbiffce8f83c2015-12-12 18:30:21 -05002635 if (part_settings->progress)
2636 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002637 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002638
2639 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2640 tw_set_default_metadata(destfn.c_str());
2641 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2642 }
2643
Ethan Yonker472f5062016-02-25 13:47:30 -06002644 ret = true;
2645exit:
2646 if (src_fd >= 0)
2647 close(src_fd);
2648 if (dest_fd >= 0)
2649 close(dest_fd);
2650 if (buffer)
2651 free(buffer);
2652 return ret;
2653}
2654
bigbiffce8f83c2015-12-12 18:30:21 -05002655bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002656 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002657
Ethan Yonker74db1572015-10-28 12:44:49 -05002658 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2659 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002660
bigbiffce8f83c2015-12-12 18:30:21 -05002661 if (part_settings->progress)
2662 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002663
Ethan Yonker472f5062016-02-25 13:47:30 -06002664 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002665 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002666
2667 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002668
Dees_Troy2673cec2013-04-02 20:22:16 +00002669 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002670 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002671 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002672 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2673 // 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 -06002674 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002675 return false;
2676 }
bigbiffce8f83c2015-12-12 18:30:21 -05002677 if (part_settings->progress)
2678 part_settings->progress->UpdateSize(Backup_Size);
2679
Dees_Troy43d8b002012-09-17 16:00:01 -04002680 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002681}
2682
bigbiffce8f83c2015-12-12 18:30:21 -05002683unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2684 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002685 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002686 if (restore_info.LoadValues() == 0) {
2687 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2688 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2689 return Restore_Size;
2690 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002691 }
2692 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002693
Matt Mower029a82d2017-01-08 13:12:38 -06002694 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2695 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002696
2697 if (Is_Image(Restore_File_System)) {
2698 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2699 return Restore_Size;
2700 }
2701
2702 twrpTar tar;
2703 tar.setdir(Backup_Path);
2704 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002705 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002706#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2707 string Password;
2708 DataManager::GetValue("tw_restore_password", Password);
2709 if (!Password.empty())
2710 tar.setpassword(Password);
2711#endif
2712 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002713 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002714 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002715 Restore_Size = tar.get_size();
2716 return Restore_Size;
2717}
2718
bigbiffce8f83c2015-12-12 18:30:21 -05002719bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002720 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002721 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002722 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002723
Dees_Troye58d5262012-09-21 12:27:57 -04002724 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002725 if (!Wipe_AndSec())
2726 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002727 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002728 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002729 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002730 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 -05002731 if (!Wipe_Data_Without_Wiping_Media())
2732 return false;
2733 } else {
2734 if (!Wipe(Restore_File_System))
2735 return false;
2736 }
Dees_Troye58d5262012-09-21 12:27:57 -04002737 }
Matt Mower3c366972015-12-25 19:28:31 -06002738 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002739 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002740
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002741 // Remount as read/write as needed so we can restore the backup
2742 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002743 return false;
2744
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002745 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002746 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002747 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002748 tar.setdir(Backup_Path);
2749 tar.setfn(Full_FileName);
2750 tar.backup_name = Backup_Name;
2751#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2752 string Password;
2753 DataManager::GetValue("tw_restore_password", Password);
2754 if (!Password.empty())
2755 tar.setpassword(Password);
2756#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002757 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2758 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002759 ret = false;
2760 else
2761 ret = true;
2762#ifdef HAVE_CAPABILITIES
2763 // Restore capabilities to the run-as binary
Captain Throwback9d6feb52018-07-27 10:05:24 -04002764 if (Mount_Point == PartitionManager.Get_Android_Root_Path() && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
Dees Troy4159aed2014-02-28 17:24:43 +00002765 struct vfs_cap_data cap_data;
2766 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2767
2768 memset(&cap_data, 0, sizeof(cap_data));
2769 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2770 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2771 cap_data.data[0].inheritable = 0;
2772 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2773 cap_data.data[1].inheritable = 0;
2774 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2775 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2776 } else {
2777 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2778 }
2779 }
2780#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002781 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2782 // Remount as read only when restoration is complete
2783 ReMount(true);
2784
Dees Troy4159aed2014-02-28 17:24:43 +00002785 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002786}
2787
bigbiffce8f83c2015-12-12 18:30:21 -05002788bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002789 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002790 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002791
Matt Mower3c366972015-12-25 19:28:31 -06002792 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002793 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002794
2795 if (part_settings->adbbackup)
2796 Full_FileName = TW_ADB_RESTORE;
2797 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002798 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002799
Ethan Yonker96af84a2015-01-05 14:58:36 -06002800 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002801 if (!part_settings->adbbackup)
2802 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2803 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002804 return false;
2805 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002806 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2807 return false;
2808 }
2809
2810 if (part_settings->adbbackup) {
2811 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002812 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002813 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002814 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002815}
Dees_Troy5bf43922012-09-07 16:07:55 -04002816
2817bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002818 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002819
Ethan Yonker1b190162016-12-05 15:25:19 -06002820 Find_Actual_Block_Device();
2821
2822 if (!Can_Be_Mounted && !Is_Encrypted) {
2823 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2824 Used = Size;
2825 Backup_Size = Size;
2826 return true;
2827 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002828 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002829 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002830
Dees_Troy0550cfb2012-10-13 11:56:13 -04002831 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04002832 if (Removable || Is_Encrypted) {
2833 if (!Mount(false))
2834 return true;
2835 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002836 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002837
2838 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002839 if (!ret || Size == 0) {
2840 if (!Get_Size_Via_df(Display_Error)) {
2841 if (!Was_Already_Mounted)
2842 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002843 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002844 }
2845 }
Dees_Troy51127312012-09-08 13:08:49 -04002846
Dees_Troy5bf43922012-09-07 16:07:55 -04002847 if (Has_Data_Media) {
2848 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002849 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002850 Backup_Size = Used;
2851 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04002852 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002853 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002854 } else {
2855 if (!Was_Already_Mounted)
2856 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002857 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002858 }
Dees_Troye58d5262012-09-21 12:27:57 -04002859 } else if (Has_Android_Secure) {
2860 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002861 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002862 else {
2863 if (!Was_Already_Mounted)
2864 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04002865 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002866 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002867 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04002868 if (!Was_Already_Mounted)
2869 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002870 return true;
Dees_Troy51127312012-09-08 13:08:49 -04002871}
Dees_Troy38bd7602012-09-14 13:33:53 -04002872
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002873bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
2874 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
2875 string Path = TWFunc::Get_Path(Device);
2876 string Dev = TWFunc::Get_Filename(Device);
2877 size_t wildcard_index = Dev.find("*");
2878 if (wildcard_index != string::npos)
2879 Dev = Dev.substr(0, wildcard_index);
2880 wildcard_index = Dev.size();
2881 DIR* d = opendir(Path.c_str());
2882 if (d == NULL) {
2883 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
2884 return false;
2885 }
2886 struct dirent* de;
2887 while ((de = readdir(d)) != NULL) {
2888 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
2889 continue;
2890
2891 string item = Path + "/";
2892 item.append(de->d_name);
2893 if (PartitionManager.Find_Partition_By_Block_Device(item))
2894 continue;
2895 TWPartition *part = new TWPartition;
2896 char buffer[MAX_FSTAB_LINE_LENGTH];
2897 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
2898 part->Process_Fstab_Line(buffer, false, NULL);
2899 char display[MAX_FSTAB_LINE_LENGTH];
2900 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
2901 part->Storage_Name = display;
2902 part->Display_Name = display;
2903 part->Primary_Block_Device = item;
2904 part->Wildcard_Block_Device = false;
2905 part->Is_SubPartition = true;
2906 part->SubPartition_Of = Mount_Point;
2907 part->Is_Storage = Is_Storage;
2908 part->Can_Be_Mounted = true;
2909 part->Removable = true;
2910 part->Can_Be_Wiped = Can_Be_Wiped;
2911 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
2912 part->Find_Actual_Block_Device();
2913 part->Update_Size(false);
2914 Has_SubPartition = true;
2915 PartitionManager.Output_Partition(part);
2916 PartitionManager.Add_Partition(part);
2917 }
2918 closedir(d);
2919 return (mount_point_index > 0);
2920}
2921
Dees_Troy38bd7602012-09-14 13:33:53 -04002922void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002923 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
2924 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
2925 * If we have a syfs entry then we are looking for this device from a uevent add.
2926 * The uevent add will set the primary block device based on the data we receive from
2927 * after checking for adopted storage. If the device ends up being adopted, then the
2928 * decrypted block device will be set instead of the primary block device. */
2929 Is_Present = false;
2930 return;
2931 }
2932 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
2933 Is_Present = false;
2934 Actual_Block_Device = "";
2935 Can_Be_Mounted = false;
2936 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
2937 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
2938 if (TWFunc::Path_Exists(Dev)) {
2939 Is_Present = true;
2940 Can_Be_Mounted = true;
2941 Actual_Block_Device = Dev;
2942 }
2943 }
2944 return;
2945 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002946 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06002947 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002948 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06002949 return;
2950 }
2951 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
2952 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
2953 unlink(Primary_Block_Device.c_str());
2954 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
2955 Is_Present = true;
2956 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04002957 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002958 Is_Present = true;
2959 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002960 return;
2961 }
Ethan Yonker1b190162016-12-05 15:25:19 -06002962 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04002963 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04002964 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002965 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04002966 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002967 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002968}
2969
2970void TWPartition::Recreate_Media_Folder(void) {
2971 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06002972 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04002973
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06002974 if (Is_FBE) {
2975 LOGINFO("Not recreating media folder on FBE\n");
2976 return;
2977 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002978 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002979 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
2980 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002981 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06002982 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
2983 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08002984 string Internal_path = DataManager::GetStrValue("tw_internal_path");
2985 if (!Internal_path.empty()) {
2986 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
2987 mkdir(Internal_path.c_str(), 0770);
2988 }
2989#ifdef TW_INTERNAL_STORAGE_PATH
2990 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
2991#endif
Matt Mower87413642017-01-17 21:14:46 -06002992
thata3d31fb2014-12-21 22:27:40 +01002993 // Afterwards, we will try to set the
2994 // default metadata that we were hopefully able to get during
2995 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06002996 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08002997 if (!Internal_path.empty())
2998 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06002999
Ethan Yonker5eac2222014-06-11 12:22:55 -05003000 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003001 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05003002 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04003003 }
Dees_Troy43d8b002012-09-17 16:00:01 -04003004}
Dees_Troye58d5262012-09-21 12:27:57 -04003005
3006void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04003007 if (!Has_Android_Secure)
3008 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00003009 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04003010 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003011 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04003012 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00003013 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003014 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05003015 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05003016 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04003017 }
3018}
bigbiff7cb4c332014-11-26 20:36:07 -05003019
3020uint64_t TWPartition::Get_Max_FileSize() {
3021 uint64_t maxFileSize = 0;
3022 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
3023 const uint64_t constTB = (uint64_t) constGB * 1024;
3024 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05003025 if (Current_File_System == "ext4")
3026 maxFileSize = 16 * constTB; //16 TB
3027 else if (Current_File_System == "vfat")
3028 maxFileSize = 4 * constGB; //4 GB
3029 else if (Current_File_System == "ntfs")
3030 maxFileSize = 256 * constTB; //256 TB
3031 else if (Current_File_System == "exfat")
3032 maxFileSize = 16 * constPB; //16 PB
3033 else if (Current_File_System == "ext3")
3034 maxFileSize = 2 * constTB; //2 TB
3035 else if (Current_File_System == "f2fs")
3036 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05003037 else
3038 maxFileSize = 100000000L;
3039 return maxFileSize - 1;
3040}
3041
bigbiffce8f83c2015-12-12 18:30:21 -05003042bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
3043 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003044
Ethan Yonkere080c1f2016-09-19 13:50:25 -05003045 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003046
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003047 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05003048
3049 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003050 LOGERR("Cannot flash images to file systems\n");
3051 return false;
3052 } else if (!Can_Flash_Img) {
3053 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
3054 return false;
3055 } else {
3056 if (!Find_Partition_Size()) {
3057 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
3058 return false;
3059 }
bigbiffce8f83c2015-12-12 18:30:21 -05003060 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003061 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05003062 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05003063 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05003064 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06003065 return false;
3066 }
bigbiffce8f83c2015-12-12 18:30:21 -05003067 if (Backup_Method == BM_DD) {
3068 if (!part_settings->adbbackup) {
3069 if (Is_Sparse_Image(full_filename)) {
3070 return Flash_Sparse_Image(full_filename);
3071 }
Ethan Yonker472f5062016-02-25 13:47:30 -06003072 }
bigbiffce8f83c2015-12-12 18:30:21 -05003073 return Raw_Read_Write(part_settings);
3074 } else if (Backup_Method == BM_FLASH_UTILS) {
3075 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06003076 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003077 }
3078
3079 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
3080 return false;
3081}
3082
Ethan Yonker472f5062016-02-25 13:47:30 -06003083bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05003084 uint32_t magic = 0;
3085 int fd = open(Filename.c_str(), O_RDONLY);
3086 if (fd < 0) {
3087 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3088 return false;
3089 }
bigbiffce8f83c2015-12-12 18:30:21 -05003090
HashBanged974bb2016-01-30 14:20:09 -05003091 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
3092 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
3093 close(fd);
3094 return false;
3095 }
3096 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06003097 if (magic == SPARSE_HEADER_MAGIC)
3098 return true;
3099 return false;
3100}
3101
3102bool TWPartition::Flash_Sparse_Image(const string& Filename) {
3103 string Command;
3104
3105 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
3106
3107 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06003108 LOGINFO("Flash command: '%s'\n", Command.c_str());
3109 TWFunc::Exec_Cmd(Command);
3110 return true;
3111}
3112
Ethan Yonker472f5062016-02-25 13:47:30 -06003113bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06003114 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06003115 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06003116
Ethan Yonker74db1572015-10-28 12:44:49 -05003117 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06003118 if (progress) {
3119 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
3120 progress->SetPartitionSize(file_size);
3121 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06003122 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
3123 Command = "erase_image " + MTD_Name;
3124 LOGINFO("Erase command: '%s'\n", Command.c_str());
3125 TWFunc::Exec_Cmd(Command);
3126 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
3127 LOGINFO("Flash command: '%s'\n", Command.c_str());
3128 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06003129 if (progress)
3130 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06003131 return true;
3132}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003133
3134void TWPartition::Change_Mount_Read_Only(bool new_value) {
3135 Mount_Read_Only = new_value;
3136}
3137
bigbiffce8f83c2015-12-12 18:30:21 -05003138bool TWPartition::Is_Read_Only() {
3139 return Mount_Read_Only;
3140}
3141
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003142int TWPartition::Check_Lifetime_Writes() {
3143 bool original_read_only = Mount_Read_Only;
3144 int ret = 1;
3145
3146 Mount_Read_Only = true;
3147 if (Mount(false)) {
3148 Find_Actual_Block_Device();
Ethan Yonker54970bb2019-01-17 16:19:24 -06003149 string temp = Actual_Block_Device;
3150 Find_Real_Block_Device(temp, false);
3151 string block = basename(temp.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05003152 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
3153 string result;
3154 if (TWFunc::Path_Exists(file)) {
3155 if (TWFunc::read_file(file, result) != 0) {
3156 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3157 } else {
3158 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3159 if (result == "0") {
3160 ret = 0;
3161 }
3162 }
3163 } else {
3164 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3165 }
3166 UnMount(true);
3167 } else {
3168 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3169 }
3170 Mount_Read_Only = original_read_only;
3171 return ret;
3172}
Ethan Yonker66a19492015-12-10 10:19:45 -06003173
3174int TWPartition::Decrypt_Adopted() {
3175#ifdef TW_INCLUDE_CRYPTO
3176 int ret = 1;
3177 Is_Adopted_Storage = false;
3178 string Adopted_Key_File = "";
3179
3180 if (!Removable)
3181 return ret;
3182
3183 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3184 if (fd < 0) {
3185 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3186 return ret;
3187 }
3188 char type_guid[80];
3189 char part_guid[80];
3190
3191 if (gpt_disk_get_partition_info(fd, 2, type_guid, part_guid) == 0) {
3192 LOGINFO("type: '%s'\n", type_guid);
3193 LOGINFO("part: '%s'\n", part_guid);
3194 Adopted_GUID = part_guid;
3195 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3196 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3197 LOGINFO("android_expand found\n");
3198 Adopted_Key_File = "/data/misc/vold/expand_";
3199 Adopted_Key_File += part_guid;
3200 Adopted_Key_File += ".key";
3201 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3202 Is_Adopted_Storage = true;
3203 /* Until we find a use case for this, I think it is safe
3204 * to disable USB Mass Storage whenever adopted storage
3205 * is present.
3206 */
3207 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3208 DataManager::SetValue("tw_has_usb_storage", 0);
3209 }
3210 }
3211 }
3212
3213 if (Is_Adopted_Storage) {
3214 string Adopted_Block_Device = Alternate_Block_Device + "p2";
3215 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3216 Adopted_Block_Device = Alternate_Block_Device + "2";
3217 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3218 LOGINFO("Adopted block device does not exist\n");
3219 goto exit;
3220 }
3221 }
3222 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3223 char crypto_blkdev[MAXPATHLEN];
3224 std::string thekey;
3225 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3226 if (fdkey < 0) {
3227 LOGINFO("failed to open key file\n");
3228 goto exit;
3229 }
3230 char buf[512];
3231 ssize_t n;
3232 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3233 thekey.append(buf, n);
3234 }
3235 close(fdkey);
3236 unsigned char* key = (unsigned char*) thekey.data();
3237 cryptfs_revert_ext_volume(part_guid);
3238
3239 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
3240 if (ret == 0) {
3241 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3242 Decrypted_Block_Device = crypto_blkdev;
3243 Is_Decrypted = true;
3244 Is_Encrypted = true;
3245 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003246 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003247 LOGERR("Failed to mount decrypted adopted storage device\n");
3248 Is_Decrypted = false;
3249 Is_Encrypted = false;
3250 cryptfs_revert_ext_volume(part_guid);
3251 ret = 1;
3252 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003253 UnMount(false);
3254 Has_Android_Secure = false;
3255 Symlink_Path = "";
3256 Symlink_Mount_Point = "";
3257 Backup_Name = Mount_Point.substr(1);
3258 Backup_Path = Mount_Point;
3259 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3260 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3261 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3262 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3263 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003264 Setup_Data_Media();
3265 Recreate_Media_Folder();
3266 Wipe_Available_in_GUI = true;
3267 Wipe_During_Factory_Reset = true;
3268 Can_Be_Backed_Up = true;
3269 Can_Encrypt_Backup = true;
3270 Use_Userdata_Encryption = true;
3271 Is_Storage = true;
3272 Storage_Name = "Adopted Storage";
3273 Is_SubPartition = true;
3274 SubPartition_Of = "/data";
3275 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3276 DataManager::SetValue("tw_has_adopted_storage", 1);
3277 }
3278 } else {
3279 LOGERR("Failed to setup adopted storage decryption\n");
3280 }
3281 }
3282exit:
Matt Mower06543e32017-01-06 15:25:26 -06003283 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003284 return ret;
3285#else
3286 LOGINFO("Decrypt_Adopted: no crypto support\n");
3287 return 1;
3288#endif
3289}
3290
3291void TWPartition::Revert_Adopted() {
3292#ifdef TW_INCLUDE_CRYPTO
3293 if (!Adopted_GUID.empty()) {
3294 PartitionManager.Remove_MTP_Storage(Mount_Point);
3295 UnMount(false);
3296 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
3297 Is_Adopted_Storage = false;
3298 Is_Encrypted = false;
3299 Is_Decrypted = false;
3300 Decrypted_Block_Device = "";
3301 Find_Actual_Block_Device();
3302 Wipe_During_Factory_Reset = false;
3303 Can_Be_Backed_Up = false;
3304 Can_Encrypt_Backup = false;
3305 Use_Userdata_Encryption = false;
3306 Is_SubPartition = false;
3307 SubPartition_Of = "";
3308 Has_Data_Media = false;
3309 Storage_Path = Mount_Point;
3310 if (!Symlink_Mount_Point.empty()) {
3311 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3312 if (Dat) {
3313 Dat->UnMount(false);
3314 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3315 }
3316 Symlink_Mount_Point = "";
3317 }
3318 }
3319#else
3320 LOGINFO("Revert_Adopted: no crypto support\n");
3321#endif
3322}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003323
3324void TWPartition::Set_Backup_FileName(string fname) {
3325 Backup_FileName = fname;
3326}
3327
3328string TWPartition::Get_Backup_Name() {
3329 return Backup_Name;
3330}