blob: 59bd168313322a1bc079d57ba20cd78a3edb03b7 [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
Dees_Troy657c3092012-09-10 20:32:10 -040034#ifdef TW_INCLUDE_CRYPTO
35 #include "cutils/properties.h"
36#endif
37
bigbiff7b4c7a62015-01-01 19:44:14 -050038#include "libblkid/include/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040039#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000040#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040041#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040042#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040043#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050044#include "twrpTar.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060045#include "exclude.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050046#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060047#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050048#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050049#include "adbbu/libtwadbbu.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040050extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040051 #include "mtdutils/mtdutils.h"
52 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000053#ifdef USE_EXT4
Ethan Yonker8373cfe2017-09-08 06:50:54 -050054 // #include "make_ext4fs.h" TODO need ifdef for android8
55 #include <ext4_utils/make_ext4fs.h>
Dees_Troya95f55c2013-08-17 13:14:43 +000056#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060057
58#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker253368a2014-11-25 15:00:52 -060059 #include "crypto/lollipop/cryptfs.h"
Ethan Yonker66a19492015-12-10 10:19:45 -060060 #include "gpt/gpt.h"
Ethan Yonkerbd7492d2016-12-07 13:55:01 -060061 #ifdef TW_INCLUDE_FBE
62 #include "crypto/ext4crypt/Decrypt.h"
Ethan Yonkerbd7492d2016-12-07 13:55:01 -060063 #endif
Ethan Yonkerbc85b632015-08-09 12:48:14 -050064#else
65 #define CRYPT_FOOTER_OFFSET 0x4000
Ethan Yonker71413f42014-02-26 13:36:08 -060066#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040067}
Matt Mower87413642017-01-17 21:14:46 -060068#include <selinux/selinux.h>
Ethan Yonkerf27497f2014-02-09 11:48:33 -060069#include <selinux/label.h>
Dees Troy4159aed2014-02-28 17:24:43 +000070#ifdef HAVE_CAPABILITIES
71#include <sys/capability.h>
72#include <sys/xattr.h>
73#include <linux/xattr.h>
74#endif
HashBanged974bb2016-01-30 14:20:09 -050075#include <sparse_format.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060076#include "progresstracking.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040077
bigbiff bigbiff9c754052013-01-09 09:09:08 -050078using namespace std;
79
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060080static int auto_index = 0; // v2 fstab allows you to specify a mount point of "auto" with no /. These items are given a mount point of /auto* where * == auto_index
81
Dees_Troya95f55c2013-08-17 13:14:43 +000082extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050083extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000084
Hashcode62bd9e02013-11-19 21:59:42 -080085struct flag_list {
86 const char *name;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060087 unsigned long flag;
Hashcode62bd9e02013-11-19 21:59:42 -080088};
89
Matt Mower4ab42b12016-04-21 13:52:18 -050090const struct flag_list mount_flags[] = {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060091 { "noatime", MS_NOATIME },
92 { "noexec", MS_NOEXEC },
93 { "nosuid", MS_NOSUID },
94 { "nodev", MS_NODEV },
95 { "nodiratime", MS_NODIRATIME },
96 { "ro", MS_RDONLY },
97 { "rw", 0 },
98 { "remount", MS_REMOUNT },
99 { "bind", MS_BIND },
100 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000101#ifdef MS_UNBINDABLE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600102 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000103#endif
104#ifdef MS_PRIVATE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600105 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000106#endif
107#ifdef MS_SLAVE
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600108 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000109#endif
110#ifdef MS_SHARED
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600111 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000112#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600113 { "sync", MS_SYNCHRONOUS },
114 { 0, 0 },
115};
116
117const char *ignored_mount_items[] = {
118 "defaults=",
119 "errors=",
120 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,
133 TWFLAG_FLASHIMG,
134 TWFLAG_FORCEENCRYPT,
135 TWFLAG_FSFLAGS,
136 TWFLAG_IGNOREBLKID,
137 TWFLAG_LENGTH,
138 TWFLAG_MOUNTTODECRYPT,
139 TWFLAG_REMOVABLE,
140 TWFLAG_RETAINLAYOUTVERSION,
141 TWFLAG_SETTINGSSTORAGE,
142 TWFLAG_STORAGE,
143 TWFLAG_STORAGENAME,
144 TWFLAG_SUBPARTITIONOF,
145 TWFLAG_SYMLINK,
146 TWFLAG_USERDATAENCRYPTBACKUP,
147 TWFLAG_USERMRF,
148 TWFLAG_WIPEDURINGFACTORYRESET,
149 TWFLAG_WIPEINGUI,
Ethan Yonker1b190162016-12-05 15:25:19 -0600150 TWFLAG_SLOTSELECT,
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600151 TWFLAG_WAIT,
152 TWFLAG_VERIFY,
153 TWFLAG_CHECK,
154 TWFLAG_ALTDEVICE,
155 TWFLAG_NOTRIM,
156 TWFLAG_VOLDMANAGED,
157 TWFLAG_FORMATTABLE,
158 TWFLAG_RESIZE,
Matt Mower2416a502016-04-12 19:54:46 -0500159};
160
161/* Flags without a trailing '=' are considered dual format flags and can be
162 * written as either 'flagname' or 'flagname=', where the character following
163 * the '=' is Y,y,1 for true and false otherwise.
164 */
165const struct flag_list tw_flags[] = {
166 { "andsec", TWFLAG_ANDSEC },
167 { "backup", TWFLAG_BACKUP },
168 { "backupname=", TWFLAG_BACKUPNAME },
169 { "blocksize=", TWFLAG_BLOCKSIZE },
170 { "canbewiped", TWFLAG_CANBEWIPED },
171 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
172 { "defaults", TWFLAG_DEFAULTS },
173 { "display=", TWFLAG_DISPLAY },
174 { "encryptable=", TWFLAG_ENCRYPTABLE },
175 { "flashimg", TWFLAG_FLASHIMG },
176 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
177 { "fsflags=", TWFLAG_FSFLAGS },
178 { "ignoreblkid", TWFLAG_IGNOREBLKID },
179 { "length=", TWFLAG_LENGTH },
180 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
181 { "removable", TWFLAG_REMOVABLE },
182 { "retainlayoutversion", TWFLAG_RETAINLAYOUTVERSION },
183 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
184 { "storage", TWFLAG_STORAGE },
185 { "storagename=", TWFLAG_STORAGENAME },
186 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
187 { "symlink=", TWFLAG_SYMLINK },
188 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
189 { "usermrf", TWFLAG_USERMRF },
190 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
191 { "wipeingui", TWFLAG_WIPEINGUI },
Ethan Yonker1b190162016-12-05 15:25:19 -0600192 { "slotselect", TWFLAG_SLOTSELECT },
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600193 { "wait", TWFLAG_WAIT },
194 { "verify", TWFLAG_VERIFY },
195 { "check", TWFLAG_CHECK },
196 { "altdevice", TWFLAG_ALTDEVICE },
197 { "notrim", TWFLAG_NOTRIM },
198 { "voldmanaged=", TWFLAG_VOLDMANAGED },
199 { "formattable", TWFLAG_FORMATTABLE },
200 { "resize", TWFLAG_RESIZE },
Matt Mower2416a502016-04-12 19:54:46 -0500201 { 0, 0 },
202};
203
that9e0593e2014-10-08 00:01:24 +0200204TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400205 Can_Be_Mounted = false;
206 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500207 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200208 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400209 Wipe_During_Factory_Reset = false;
210 Wipe_Available_in_GUI = false;
211 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400212 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400213 SubPartition_Of = "";
214 Symlink_Path = "";
215 Symlink_Mount_Point = "";
216 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400217 Backup_Path = "";
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600218 Wildcard_Block_Device = false;
219 Sysfs_Entry = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400220 Actual_Block_Device = "";
221 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400222 Alternate_Block_Device = "";
223 Removable = false;
224 Is_Present = false;
225 Length = 0;
226 Size = 0;
227 Used = 0;
228 Free = 0;
229 Backup_Size = 0;
230 Can_Be_Encrypted = false;
231 Is_Encrypted = false;
232 Is_Decrypted = false;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600233 Is_FBE = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600234 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400235 Decrypted_Block_Device = "";
236 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500237 Backup_Display_Name = "";
238 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400239 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400240 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400241 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500242 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000243 Can_Encrypt_Backup = false;
244 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400245 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400246 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400247 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500248 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400249 Storage_Path = "";
250 Current_File_System = "";
251 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800252 Mount_Flags = 0;
253 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400254 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000255 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +0000256 Retain_Layout_Version = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600257 Crypto_Key_Location = "footer";
Ethan Yonker726a0202014-12-16 20:01:38 -0600258 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600259 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500260 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600261 Is_Adopted_Storage = false;
262 Adopted_GUID = "";
Ethan Yonker1b190162016-12-05 15:25:19 -0600263 SlotSelect = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400264}
265
266TWPartition::~TWPartition(void) {
267 // Do nothing
268}
269
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600270bool 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 -0500271 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500272 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400273 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500274 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500275 bool skip = false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600276 int fstab_version = 1, mount_point_index = 0, fs_index = 1, block_device_index = 2;
277 TWPartition *additional_entry = NULL;
278 std::map<string, Flags_Map>::iterator it;
Dees_Troy5bf43922012-09-07 16:07:55 -0400279
Matt Mower2b2dd152016-04-26 11:24:08 -0500280 strlcpy(full_line, fstab_line, sizeof(full_line));
Dees_Troy51127312012-09-08 13:08:49 -0400281 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500282 if (full_line[index] == 34)
283 skip = !skip;
284 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400285 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400286 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600287 if (line_len < 10)
288 return false; // There can't possibly be a valid fstab line that is less than 10 chars
289 if (strncmp(fstab_line, "/dev/", strlen("/dev/")) == 0 || strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
290 fstab_version = 2;
291 block_device_index = 0;
292 mount_point_index = 1;
293 fs_index = 2;
294 }
295
296 index = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -0400297 while (index < line_len) {
298 while (index < line_len && full_line[index] == '\0')
299 index++;
300 if (index >= line_len)
301 continue;
302 ptr = full_line + index;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600303 if (item_index == mount_point_index) {
304 Mount_Point = ptr;
305 if (fstab_version == 2) {
306 additional_entry = PartitionManager.Find_Partition_By_Path(Mount_Point);
307 if (additional_entry) {
308 LOGINFO("Found an additional entry for '%s'\n", Mount_Point.c_str());
309 }
310 }
311 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
312 Backup_Path = Mount_Point;
313 Storage_Path = Mount_Point;
314 Display_Name = ptr + 1;
315 Backup_Display_Name = Display_Name;
316 Storage_Name = Display_Name;
317 item_index++;
318 } else if (item_index == fs_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400319 // File System
320 Fstab_File_System = ptr;
321 Current_File_System = ptr;
322 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600323 } else if (item_index == block_device_index) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400324 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400325 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400326 MTD_Name = ptr;
327 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400328 } else if (Fstab_File_System == "bml") {
329 if (Mount_Point == "/boot")
330 MTD_Name = "boot";
331 else if (Mount_Point == "/recovery")
332 MTD_Name = "recovery";
333 Primary_Block_Device = ptr;
334 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000335 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 -0400336 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400337 if (Display_Error)
Matt Mower2b2dd152016-04-26 11:24:08 -0500338 LOGERR("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400339 else
Matt Mower2b2dd152016-04-26 11:24:08 -0500340 LOGINFO("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
Matt Mower72c87ce2016-04-26 14:34:56 -0500341 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400342 } else {
343 Primary_Block_Device = ptr;
344 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400345 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400346 item_index++;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600347 } else if (item_index > 2) {
348 if (fstab_version == 2) {
349 if (item_index == 3) {
350 Process_FS_Flags(ptr);
351 if (additional_entry) {
352 additional_entry->Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
353 return false; // We save the extra fs flags in the other partition entry and by returning false, this entry will be deleted
354 }
355 } else {
356 strlcpy(twflags, ptr, sizeof(twflags));
357 }
358 item_index++;
359 } else if (*ptr == '/') { // v2 fstab does not allow alternate block devices
Dees_Troy5bf43922012-09-07 16:07:55 -0400360 // Alternate Block Device
361 Alternate_Block_Device = ptr;
362 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
363 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
364 // Partition length
365 ptr += 7;
366 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400367 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
368 // Custom flags, save for later so that new values aren't overwritten by defaults
369 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500370 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400371 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
372 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400373 } else {
374 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500375 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400376 }
377 }
378 while (index < line_len && full_line[index] != '\0')
379 index++;
380 }
381
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600382 // override block devices from the v2 fstab with the ones we read from the twrp.flags file in case they are different
383 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
384 it = twrp_flags->find(Mount_Point);
385 if (it != twrp_flags->end()) {
386 if (!it->second.Primary_Block_Device.empty()) {
387 Primary_Block_Device = it->second.Primary_Block_Device;
388 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
389 }
390 if (!it->second.Alternate_Block_Device.empty()) {
391 Alternate_Block_Device = it->second.Alternate_Block_Device;
392 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
393 }
394 }
395 }
396
397 if (strncmp(fstab_line, "/devices/", strlen("/devices/")) == 0) {
398 Sysfs_Entry = Primary_Block_Device;
399 Primary_Block_Device = "";
400 Is_Storage = true;
401 Removable = true;
402 Wipe_Available_in_GUI = true;
403 Wildcard_Block_Device = true;
404 }
405 if (Primary_Block_Device.find("*") != string::npos)
406 Wildcard_Block_Device = true;
407
408 if (Mount_Point == "auto") {
409 Mount_Point = "/auto";
410 char autoi[5];
411 sprintf(autoi, "%i", auto_index);
412 Mount_Point += autoi;
413 Backup_Path = Mount_Point;
414 Storage_Path = Mount_Point;
415 auto_index++;
416 Setup_File_System(Display_Error);
417 Display_Name = "Storage";
418 Backup_Display_Name = Display_Name;
419 Storage_Name = Display_Name;
420 Can_Be_Backed_Up = false;
421 Wipe_Available_in_GUI = true;
422 Is_Storage = true;
423 Removable = true;
424 Wipe_Available_in_GUI = true;
425 } else if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400426 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000427 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400428 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000429 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500430 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400431 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400432 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400433 Setup_File_System(Display_Error);
434 if (Mount_Point == "/system") {
435 Display_Name = "System";
Dees_Troya13d74f2013-03-24 08:54:55 -0500436 Backup_Display_Name = Display_Name;
437 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400438 Wipe_Available_in_GUI = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500439 Can_Be_Backed_Up = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500440 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400441 } else if (Mount_Point == "/data") {
442 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500443 Backup_Display_Name = Display_Name;
444 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400445 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400446 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500447 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000448 Can_Encrypt_Backup = true;
449 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400450 } else if (Mount_Point == "/cache") {
451 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500452 Backup_Display_Name = Display_Name;
453 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400454 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400455 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500456 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400457 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400458 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400459 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500460 Backup_Display_Name = Display_Name;
461 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400462 Is_SubPartition = true;
463 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400464 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500465 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000466 Can_Encrypt_Backup = true;
467 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400468 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400469 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400470 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500471 Backup_Display_Name = Display_Name;
472 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400473 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400474 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500475 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000476 Can_Encrypt_Backup = true;
477 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400478 } else if (Mount_Point == "/boot") {
479 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500480 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400481 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500482 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500483 } else if (Mount_Point == "/vendor") {
484 Display_Name = "Vendor";
485 Backup_Display_Name = Display_Name;
486 Storage_Name = Display_Name;
487 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400488 }
489#ifdef TW_EXTERNAL_STORAGE_PATH
490 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
491 Is_Storage = true;
492 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400493 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500494 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400495#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000496 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400497 Is_Storage = true;
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#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000501 }
Dees_Troy8170a922012-09-18 15:40:25 -0400502#ifdef TW_INTERNAL_STORAGE_PATH
503 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
504 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500505 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400506 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500507 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400508 }
509#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000510 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400511 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500512 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500513 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400514 }
515#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400516 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400517 Find_Actual_Block_Device();
Ethan Yonker1b190162016-12-05 15:25:19 -0600518 Setup_Image();
Dees_Troya13d74f2013-03-24 08:54:55 -0500519 if (Mount_Point == "/boot") {
520 Display_Name = "Boot";
521 Backup_Display_Name = Display_Name;
522 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600523 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500524 } else if (Mount_Point == "/recovery") {
525 Display_Name = "Recovery";
526 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600527 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500528 } else if (Mount_Point == "/system_image") {
529 Display_Name = "System Image";
530 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500531 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500532 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500533 } else if (Mount_Point == "/vendor_image") {
534 Display_Name = "Vendor Image";
535 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500536 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500537 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500538 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400539 }
540
Matt Mower2416a502016-04-12 19:54:46 -0500541 // Process TWRP fstab flags
542 if (strlen(twflags) > 0) {
543 string Prev_Display_Name = Display_Name;
544 string Prev_Storage_Name = Storage_Name;
545 string Prev_Backup_Display_Name = Backup_Display_Name;
546 Display_Name = "";
547 Storage_Name = "";
548 Backup_Display_Name = "";
549
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600550 Process_TW_Flags(twflags, (fstab_version == 1), fstab_version);
551 Save_FS_Flags(Fstab_File_System, Mount_Flags, Mount_Options);
Matt Mower2416a502016-04-12 19:54:46 -0500552
553 bool has_display_name = !Display_Name.empty();
554 bool has_storage_name = !Storage_Name.empty();
555 bool has_backup_name = !Backup_Display_Name.empty();
556 if (!has_display_name) Display_Name = Prev_Display_Name;
557 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
558 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
559
560 if (has_display_name && !has_storage_name)
561 Storage_Name = Display_Name;
562 if (!has_display_name && has_storage_name)
563 Display_Name = Storage_Name;
564 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
565 Backup_Display_Name = Display_Name;
566 if (!has_display_name && has_backup_name)
567 Display_Name = Backup_Display_Name;
568 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600569
570 if (fstab_version == 2 && twrp_flags && twrp_flags->size() > 0) {
571 it = twrp_flags->find(Mount_Point);
572 if (it != twrp_flags->end()) {
573 char twrpflags[MAX_FSTAB_LINE_LENGTH] = "";
574 int skip = 0;
575 string Flags = it->second.Flags;
576 strcpy(twrpflags, Flags.c_str());
577 if (strlen(twrpflags) > strlen("flags=") && strncmp(twrpflags, "flags=", strlen("flags=")) == 0)
578 skip += strlen("flags=");
579 char* flagptr = twrpflags;
580 flagptr += skip;
581 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
582 }
583 }
nkk7198fc3992017-12-16 16:26:42 +0200584
585 if (Mount_Point == "/persist" && Can_Be_Mounted) {
586 bool mounted = Is_Mounted();
587 if (mounted || Mount(false)) {
588 // Read the backup settings file
589 DataManager::LoadPersistValues();
590 TWFunc::Fixup_Time_On_Boot("/persist/time/");
591 if (!mounted)
592 UnMount(false);
593 }
594 }
595
Dees_Troy51127312012-09-08 13:08:49 -0400596 return true;
597}
598
Matt Mower72c87ce2016-04-26 14:34:56 -0500599void TWPartition::Partition_Post_Processing(bool Display_Error) {
600 if (Mount_Point == "/data")
601 Setup_Data_Partition(Display_Error);
602 else if (Mount_Point == "/cache")
603 Setup_Cache_Partition(Display_Error);
604}
605
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600606void TWPartition::ExcludeAll(const string& path) {
607 backup_exclusions.add_absolute_dir(path);
608 wipe_exclusions.add_absolute_dir(path);
609}
610
Matt Mower72c87ce2016-04-26 14:34:56 -0500611void TWPartition::Setup_Data_Partition(bool Display_Error) {
612 if (Mount_Point != "/data")
613 return;
614
615 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
616 UnMount(false);
617
618#ifdef TW_INCLUDE_CRYPTO
619 if (datamedia)
620 Setup_Data_Media();
621 Can_Be_Encrypted = true;
622 char crypto_blkdev[255];
623 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
624 if (strcmp(crypto_blkdev, "error") != 0) {
625 DataManager::SetValue(TW_IS_DECRYPTED, 1);
626 Is_Encrypted = true;
627 Is_Decrypted = true;
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600628 Is_FBE = false;
629 DataManager::SetValue(TW_IS_FBE, 0);
Matt Mower72c87ce2016-04-26 14:34:56 -0500630 Decrypted_Block_Device = crypto_blkdev;
631 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
632 } else if (!Mount(false)) {
633 if (Is_Present) {
634 set_partition_data(Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(), Fstab_File_System.c_str());
635 if (cryptfs_check_footer() == 0) {
636 Is_Encrypted = true;
637 Is_Decrypted = false;
638 Can_Be_Mounted = false;
639 Current_File_System = "emmc";
Ethan Yonker1b190162016-12-05 15:25:19 -0600640 Setup_Image();
Matt Mower72c87ce2016-04-26 14:34:56 -0500641 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
642 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
643 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
644 DataManager::SetValue("tw_crypto_display", "");
645 } else {
646 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
647 }
648 } else {
649 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
650 }
651 } else {
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600652 if (TWFunc::Path_Exists("/data/unencrypted/key/version")) {
653 LOGINFO("File Based Encryption is present\n");
654#ifdef TW_INCLUDE_FBE
655 ExcludeAll(Mount_Point + "/convert_fbe");
656 ExcludeAll(Mount_Point + "/unencrypted");
657 //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
658 ExcludeAll(Mount_Point + "/misc/vold/user_keys");
Ethan Yonker79f88bd2016-12-09 14:52:12 -0600659 //ExcludeAll(Mount_Point + "/system_ce");
660 //ExcludeAll(Mount_Point + "/system_de");
661 //ExcludeAll(Mount_Point + "/misc_ce");
662 //ExcludeAll(Mount_Point + "/misc_de");
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600663 ExcludeAll(Mount_Point + "/system/gatekeeper.password.key");
664 ExcludeAll(Mount_Point + "/system/gatekeeper.pattern.key");
665 ExcludeAll(Mount_Point + "/system/locksettings.db");
666 //ExcludeAll(Mount_Point + "/system/locksettings.db-shm"); // don't seem to need this one, but the other 2 are needed
667 ExcludeAll(Mount_Point + "/system/locksettings.db-wal");
Ethan Yonker79f88bd2016-12-09 14:52:12 -0600668 //ExcludeAll(Mount_Point + "/user_de");
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600669 //ExcludeAll(Mount_Point + "/misc/profiles/cur/0"); // might be important later
670 ExcludeAll(Mount_Point + "/misc/gatekeeper");
Ethan Yonkerfefe5912017-09-30 22:22:13 -0500671 ExcludeAll(Mount_Point + "/misc/keystore");
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600672 ExcludeAll(Mount_Point + "/drm/kek.dat");
Ethan Yonkerfefe5912017-09-30 22:22:13 -0500673 ExcludeAll(Mount_Point + "/system_de/0/spblob"); // contains data needed to decrypt pixel 2
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600674 int retry_count = 3;
675 while (!Decrypt_DE() && --retry_count)
676 usleep(2000);
677 if (retry_count > 0) {
678 property_set("ro.crypto.state", "encrypted");
679 Is_Encrypted = true;
680 Is_Decrypted = false;
681 Is_FBE = true;
682 DataManager::SetValue(TW_IS_FBE, 1);
683 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
684 string filename;
Ethan Yonkerfefe5912017-09-30 22:22:13 -0500685 int pwd_type = Get_Password_Type(0, filename);
686 if (pwd_type < 0) {
687 LOGERR("This TWRP does not have synthetic password decrypt support\n");
688 pwd_type = 0; // default password
689 }
690 DataManager::SetValue(TW_CRYPTO_PWTYPE, pwd_type);
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600691 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
692 DataManager::SetValue("tw_crypto_display", "");
693 }
694#else
695 LOGERR("FBE found but FBE support not present in TWRP\n");
696#endif
697 } else {
698 // Filesystem is not encrypted and the mount succeeded, so return to
699 // the original unmounted state
700 UnMount(false);
701 }
Matt Mower72c87ce2016-04-26 14:34:56 -0500702 }
703 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
704 Setup_Data_Media();
705 Recreate_Media_Folder();
706 }
707#else
708 if (datamedia) {
709 Setup_Data_Media();
710 Recreate_Media_Folder();
711 }
712#endif
713}
714
715void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
716 if (Mount_Point != "/cache")
717 return;
718
719 if (!Mount(true))
720 return;
721
722 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
723 LOGINFO("Recreating /cache/recovery folder\n");
724 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
725 LOGERR("Could not create /cache/recovery\n");
726 }
727}
728
Matt Mower4ab42b12016-04-21 13:52:18 -0500729void TWPartition::Process_FS_Flags(const char *str) {
730 char *options = strdup(str);
731 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800732
Matt Mower4ab42b12016-04-21 13:52:18 -0500733 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800734
Matt Mower4ab42b12016-04-21 13:52:18 -0500735 // Avoid issues with potentially nested strtok by using strtok_r
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600736 for (ptr = strtok_r(options, ",", &savep); ptr; ptr = strtok_r(NULL, ",", &savep)) {
737 char *equals = strstr(ptr, "=");
738 size_t name_len;
Matt Mower4ab42b12016-04-21 13:52:18 -0500739
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600740 if (!equals)
741 name_len = strlen(ptr);
742 else
743 name_len = equals - ptr;
744
745 // There are some flags that we want to ignore in TWRP
746 bool found_match = false;
747 for (const char** ignored_mount_item = ignored_mount_items; *ignored_mount_item; ignored_mount_item++) {
748 if (strncmp(ptr, *ignored_mount_item, name_len) == 0) {
749 found_match = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800750 break;
751 }
752 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600753 if (found_match)
754 continue;
Hashcode62bd9e02013-11-19 21:59:42 -0800755
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600756 // mount_flags are never postfixed by '='
757 if (!equals) {
758 const struct flag_list* mount_flag = mount_flags;
759 for (; mount_flag->name; mount_flag++) {
760 if (strcmp(ptr, mount_flag->name) == 0) {
761 if (mount_flag->flag == MS_RDONLY)
762 Mount_Read_Only = true;
763 else
764 Mount_Flags |= (unsigned)mount_flag->flag;
765 found_match = true;
766 break;
767 }
768 }
769 if (found_match)
770 continue;
Matt Mower4ab42b12016-04-21 13:52:18 -0500771 }
772
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600773 // If we aren't ignoring this flag and it's not a mount flag, then it must be a mount option
774 if (!Mount_Options.empty())
775 Mount_Options += ",";
776 Mount_Options += ptr;
Matt Mower4ab42b12016-04-21 13:52:18 -0500777 }
778 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800779}
780
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600781void TWPartition::Save_FS_Flags(const string& local_File_System, int local_Mount_Flags, const string& local_Mount_Options) {
782 partition_fs_flags_struct flags;
783 flags.File_System = local_File_System;
784 flags.Mount_Flags = local_Mount_Flags;
785 flags.Mount_Options = local_Mount_Options;
786 fs_flags.push_back(flags);
787}
788
Matt Mower2416a502016-04-12 19:54:46 -0500789void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
790 switch (flag) {
791 case TWFLAG_ANDSEC:
792 Has_Android_Secure = val;
793 break;
794 case TWFLAG_BACKUP:
795 Can_Be_Backed_Up = val;
796 break;
797 case TWFLAG_BACKUPNAME:
798 Backup_Display_Name = str;
799 break;
800 case TWFLAG_BLOCKSIZE:
801 Format_Block_Size = (unsigned long)(atol(str));
802 break;
803 case TWFLAG_CANBEWIPED:
804 Can_Be_Wiped = val;
805 break;
806 case TWFLAG_CANENCRYPTBACKUP:
807 Can_Encrypt_Backup = val;
808 break;
809 case TWFLAG_DEFAULTS:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600810 case TWFLAG_WAIT:
811 case TWFLAG_VERIFY:
812 case TWFLAG_CHECK:
813 case TWFLAG_NOTRIM:
814 case TWFLAG_VOLDMANAGED:
815 case TWFLAG_RESIZE:
Matt Mower2416a502016-04-12 19:54:46 -0500816 // Do nothing
817 break;
818 case TWFLAG_DISPLAY:
819 Display_Name = str;
820 break;
821 case TWFLAG_ENCRYPTABLE:
822 case TWFLAG_FORCEENCRYPT:
823 Crypto_Key_Location = str;
824 break;
825 case TWFLAG_FLASHIMG:
826 Can_Flash_Img = val;
827 break;
828 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500829 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500830 break;
831 case TWFLAG_IGNOREBLKID:
832 Ignore_Blkid = val;
833 break;
834 case TWFLAG_LENGTH:
835 Length = atoi(str);
836 break;
837 case TWFLAG_MOUNTTODECRYPT:
838 Mount_To_Decrypt = val;
839 break;
840 case TWFLAG_REMOVABLE:
841 Removable = val;
842 break;
843 case TWFLAG_RETAINLAYOUTVERSION:
844 Retain_Layout_Version = val;
845 break;
846 case TWFLAG_SETTINGSSTORAGE:
847 Is_Settings_Storage = val;
848 if (Is_Settings_Storage)
849 Is_Storage = true;
850 break;
851 case TWFLAG_STORAGE:
852 Is_Storage = val;
853 break;
854 case TWFLAG_STORAGENAME:
855 Storage_Name = str;
856 break;
857 case TWFLAG_SUBPARTITIONOF:
858 Is_SubPartition = true;
859 SubPartition_Of = str;
860 break;
861 case TWFLAG_SYMLINK:
862 Symlink_Path = str;
863 break;
864 case TWFLAG_USERDATAENCRYPTBACKUP:
865 Use_Userdata_Encryption = val;
866 if (Use_Userdata_Encryption)
867 Can_Encrypt_Backup = true;
868 break;
869 case TWFLAG_USERMRF:
870 Use_Rm_Rf = val;
871 break;
872 case TWFLAG_WIPEDURINGFACTORYRESET:
873 Wipe_During_Factory_Reset = val;
874 if (Wipe_During_Factory_Reset) {
875 Can_Be_Wiped = true;
876 Wipe_Available_in_GUI = true;
877 }
878 break;
879 case TWFLAG_WIPEINGUI:
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600880 case TWFLAG_FORMATTABLE:
Matt Mower2416a502016-04-12 19:54:46 -0500881 Wipe_Available_in_GUI = val;
882 if (Wipe_Available_in_GUI)
883 Can_Be_Wiped = true;
884 break;
Ethan Yonker1b190162016-12-05 15:25:19 -0600885 case TWFLAG_SLOTSELECT:
886 SlotSelect = true;
887 break;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600888 case TWFLAG_ALTDEVICE:
889 Alternate_Block_Device = str;
890 break;
Matt Mower2416a502016-04-12 19:54:46 -0500891 default:
892 // Should not get here
893 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
894 break;
895 }
896}
Dees_Troy51127312012-09-08 13:08:49 -0400897
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600898void TWPartition::Process_TW_Flags(char *flags, bool Display_Error, int fstab_ver) {
Matt Mower2416a502016-04-12 19:54:46 -0500899 char separator[2] = {'\n', 0};
900 char *ptr, *savep;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600901 char source_separator = ';';
902
903 if (fstab_ver == 2)
904 source_separator = ',';
Matt Mower2416a502016-04-12 19:54:46 -0500905
906 // Semicolons within double-quotes are not forbidden, so replace
907 // only the semicolons intended as separators with '\n' for strtok
908 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
909 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -0500910 skip = !skip;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600911 if (!skip && flags[i] == source_separator)
Matt Mower2416a502016-04-12 19:54:46 -0500912 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -0400913 }
914
Matt Mower2416a502016-04-12 19:54:46 -0500915 // Avoid issues with potentially nested strtok by using strtok_r
916 ptr = strtok_r(flags, separator, &savep);
917 while (ptr) {
918 int ptr_len = strlen(ptr);
919 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -0800920
Matt Mower2416a502016-04-12 19:54:46 -0500921 for (; tw_flag->name; tw_flag++) {
922 int flag_len = strlen(tw_flag->name);
923
924 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
925 bool flag_val = false;
926
927 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
928 && ptr[flag_len] != '=') {
929 // Handle flags with same starting string
930 // (e.g. backup and backupname)
931 continue;
932 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
933 // Handle flags with dual format: Part 1
934 // (e.g. backup and backup=y. backup=y handled here)
935 ptr += flag_len + 1;
936 TWFunc::Strip_Quotes(ptr);
937 // Skip flags with empty argument
938 // (e.g. backup=)
939 if (strlen(ptr) == 0) {
940 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
941 break;
942 }
943 flag_val = strchr("yY1", *ptr) != NULL;
944 } else if (ptr_len == flag_len
945 && (tw_flag->name)[flag_len-1] == '=') {
946 // Skip flags missing argument after =
947 // (e.g. backupname=)
948 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
949 break;
950 } else if (ptr_len > flag_len
951 && (tw_flag->name)[flag_len-1] == '=') {
952 // Handle arguments to flags
953 // (e.g. backupname="My Stuff")
954 ptr += flag_len;
955 TWFunc::Strip_Quotes(ptr);
956 // Skip flags with empty argument
957 // (e.g. backupname="")
958 if (strlen(ptr) == 0) {
959 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
960 break;
961 }
962 } else if (ptr_len == flag_len) {
963 // Handle flags with dual format: Part 2
964 // (e.g. backup and backup=y. backup handled here)
965 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600966 } else {
Matt Mower2416a502016-04-12 19:54:46 -0500967 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
968 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600969 }
Matt Mower2416a502016-04-12 19:54:46 -0500970
971 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
972 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600973 }
Matt Mower2416a502016-04-12 19:54:46 -0500974 }
975 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400976 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000977 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400978 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000979 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400980 }
Matt Mower2416a502016-04-12 19:54:46 -0500981 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -0400982 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400983}
984
Dees_Troy5bf43922012-09-07 16:07:55 -0400985bool TWPartition::Is_File_System(string File_System) {
986 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -0400987 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400988 File_System == "ext4" ||
989 File_System == "vfat" ||
990 File_System == "ntfs" ||
991 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -0500992 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +0000993 File_System == "f2fs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400994 File_System == "auto")
995 return true;
996 else
997 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400998}
999
Dees_Troy5bf43922012-09-07 16:07:55 -04001000bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -04001001 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -04001002 return true;
1003 else
1004 return false;
1005}
1006
Dees_Troy51127312012-09-08 13:08:49 -04001007bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Ethan Yonker93ac7a02016-11-07 22:05:58 -06001008 if (TWFunc::Get_D_Type_From_Stat(Path) != S_IFDIR)
1009 unlink(Path.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001010 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -04001011 if (mkdir(Path.c_str(), 0777) == -1) {
1012 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001013 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -04001014 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001015 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001016 return false;
1017 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001018 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001019 return true;
1020 }
1021 }
1022 return true;
1023}
1024
Dees_Troy5bf43922012-09-07 16:07:55 -04001025void TWPartition::Setup_File_System(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001026 Can_Be_Mounted = true;
1027 Can_Be_Wiped = true;
1028
Dees_Troy5bf43922012-09-07 16:07:55 -04001029 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -04001030 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -04001031 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1032 Backup_Name = Display_Name;
bigbiffce8f83c2015-12-12 18:30:21 -05001033 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -04001034}
1035
Ethan Yonker1b190162016-12-05 15:25:19 -06001036void TWPartition::Setup_Image() {
Dees_Troy5bf43922012-09-07 16:07:55 -04001037 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
1038 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -08001039 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -05001040 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -08001041 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -05001042 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -04001043 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001044 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 -04001045}
1046
Dees_Troye58d5262012-09-21 12:27:57 -04001047void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -05001048 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -04001049 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -05001050 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -04001051 Has_Android_Secure = true;
1052 Symlink_Path = Mount_Point + "/.android_secure";
1053 Symlink_Mount_Point = "/and-sec";
1054 Backup_Path = Symlink_Mount_Point;
1055 Make_Dir("/and-sec", true);
1056 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +00001057 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -04001058}
1059
that9e0593e2014-10-08 00:01:24 +02001060void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -05001061 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -06001062 if (Storage_Name.empty() || Storage_Name == "Data")
1063 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -05001064 Has_Data_Media = true;
1065 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06001066 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -05001067 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -06001068 if (Mount_Point == "/data") {
1069 Is_Settings_Storage = true;
1070 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
1071 Make_Dir("/emmc", false);
1072 Symlink_Mount_Point = "/emmc";
1073 } else {
1074 Make_Dir("/sdcard", false);
1075 Symlink_Mount_Point = "/sdcard";
1076 }
1077 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1078 Storage_Path = Mount_Point + "/media/0";
1079 Symlink_Path = Storage_Path;
1080 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
1081 UnMount(true);
1082 }
1083 DataManager::SetValue("tw_has_internal", 1);
1084 DataManager::SetValue("tw_has_data_media", 1);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06001085 backup_exclusions.add_absolute_dir("/data/data/com.google.android.music/files");
Ethan Yonker6355b562017-05-01 09:42:17 -05001086 wipe_exclusions.add_absolute_dir(Mount_Point + "/misc/vold"); // adopted storage keys
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001087 ExcludeAll(Mount_Point + "/.layout_version");
1088 ExcludeAll(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -05001089 } else {
Ethan Yonker66a19492015-12-10 10:19:45 -06001090 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
1091 Storage_Path = Mount_Point + "/media/0";
1092 Symlink_Path = Storage_Path;
1093 UnMount(true);
1094 }
Ethan Yonker6277c792014-09-15 14:54:30 -05001095 }
Ethan Yonker79f88bd2016-12-09 14:52:12 -06001096 ExcludeAll(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -05001097}
1098
Dees_Troy5bf43922012-09-07 16:07:55 -04001099void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001100 char device[PATH_MAX], realDevice[PATH_MAX];
Dees_Troy5bf43922012-09-07 16:07:55 -04001101
1102 strcpy(device, Block.c_str());
1103 memset(realDevice, 0, sizeof(realDevice));
1104 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
1105 {
1106 strcpy(device, realDevice);
1107 memset(realDevice, 0, sizeof(realDevice));
1108 }
1109
1110 if (device[0] != '/') {
1111 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001112 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001113 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001114 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001115 return;
Dees_Troy51a0e822012-09-05 15:24:24 -04001116 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001117 Block = device;
1118 return;
1119 }
1120}
1121
Kjell Braden3126a112016-06-19 16:58:15 +00001122bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001123 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +00001124 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -04001125 int retry_count = 5;
1126 while (retry_count > 0 && !Mount(false)) {
1127 usleep(500000);
1128 retry_count--;
1129 }
Kjell Braden3126a112016-06-19 16:58:15 +00001130 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -04001131 }
Kjell Braden3126a112016-06-19 16:58:15 +00001132 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -04001133}
1134
Dees_Troy38bd7602012-09-14 13:33:53 -04001135bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
1136 FILE *fp = NULL;
1137 char line[255];
1138
1139 fp = fopen("/proc/mtd", "rt");
1140 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001141 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001142 return false;
1143 }
1144
1145 while (fgets(line, sizeof(line), fp) != NULL)
1146 {
1147 char device[32], label[32];
1148 unsigned long size = 0;
Dees_Troy38bd7602012-09-14 13:33:53 -04001149 int deviceId;
1150
1151 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
1152
1153 // Skip header and blank lines
1154 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
1155 continue;
1156
1157 // Strip off the trailing " from the label
1158 label[strlen(label)-1] = '\0';
1159
1160 if (strcmp(label, MTD_Name.c_str()) == 0) {
1161 // We found our device
1162 // Strip off the trailing : from the device
1163 device[strlen(device)-1] = '\0';
1164 if (sscanf(device,"mtd%d", &deviceId) == 1) {
1165 sprintf(device, "/dev/block/mtdblock%d", deviceId);
1166 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +00001167 fclose(fp);
1168 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001169 }
1170 }
1171 }
1172 fclose(fp);
1173
1174 return false;
1175}
1176
Dees_Troy51127312012-09-08 13:08:49 -04001177bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
1178 struct statfs st;
1179 string Local_Path = Mount_Point + "/.";
1180
1181 if (!Mount(Display_Error))
1182 return false;
1183
1184 if (statfs(Local_Path.c_str(), &st) != 0) {
1185 if (!Removable) {
1186 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001187 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001188 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001189 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -04001190 }
1191 return false;
1192 }
1193 Size = (st.f_blocks * st.f_bsize);
1194 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
1195 Free = (st.f_bfree * st.f_bsize);
1196 Backup_Size = Used;
1197 return true;
1198}
1199
1200bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001201 FILE* fp;
1202 char command[255], line[512];
1203 int include_block = 1;
1204 unsigned int min_len;
1205
1206 if (!Mount(Display_Error))
1207 return false;
1208
Dees_Troy38bd7602012-09-14 13:33:53 -04001209 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -04001210 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001211 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -04001212 fp = fopen("/tmp/dfoutput.txt", "rt");
1213 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001214 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001215 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001216 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001217
1218 while (fgets(line, sizeof(line), fp) != NULL)
1219 {
1220 unsigned long blocks, used, available;
1221 char device[64];
1222 char tmpString[64];
1223
1224 if (strncmp(line, "Filesystem", 10) == 0)
1225 continue;
1226 if (strlen(line) < min_len) {
1227 include_block = 0;
1228 continue;
1229 }
1230 if (include_block) {
1231 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1232 } else {
1233 // The device block string is so long that the df information is on the next line
1234 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001235 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001236 while (tmpString[space_count] == 32)
1237 space_count++;
1238 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1239 }
1240
1241 // Adjust block size to byte size
1242 Size = blocks * 1024ULL;
1243 Used = used * 1024ULL;
1244 Free = available * 1024ULL;
1245 Backup_Size = Used;
1246 }
1247 fclose(fp);
1248 return true;
1249}
1250
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001251unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001252 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001253
1254 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001255}
1256
Dees_Troy5bf43922012-09-07 16:07:55 -04001257bool TWPartition::Find_Partition_Size(void) {
1258 FILE* fp;
1259 char line[512];
1260 string tmpdevice;
1261
igoriok87e3d932013-01-31 21:03:53 +02001262 fp = fopen("/proc/dumchar_info", "rt");
1263 if (fp != NULL) {
1264 while (fgets(line, sizeof(line), fp) != NULL)
1265 {
1266 char label[32], device[32];
1267 unsigned long size = 0;
1268
thatd43bf2d2014-09-21 23:13:02 +02001269 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001270
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001271 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001272 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1273 continue;
1274
1275 tmpdevice = "/dev/";
1276 tmpdevice += label;
1277 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1278 Size = size;
1279 fclose(fp);
1280 return true;
1281 }
1282 }
1283 }
1284
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001285 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1286 if (ioctl_size) {
1287 Size = ioctl_size;
1288 return true;
1289 }
1290
Dees_Troy5bf43922012-09-07 16:07:55 -04001291 // In this case, we'll first get the partitions we care about (with labels)
1292 fp = fopen("/proc/partitions", "rt");
1293 if (fp == NULL)
1294 return false;
1295
1296 while (fgets(line, sizeof(line), fp) != NULL)
1297 {
1298 unsigned long major, minor, blocks;
1299 char device[512];
Dees_Troy5bf43922012-09-07 16:07:55 -04001300
Dees_Troy63c8df72012-09-10 14:02:05 -04001301 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001302 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1303
1304 tmpdevice = "/dev/block/";
1305 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001306 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001307 // Adjust block size to byte size
1308 Size = blocks * 1024ULL;
1309 fclose(fp);
1310 return true;
1311 }
1312 }
1313 fclose(fp);
1314 return false;
1315}
1316
Dees_Troy5bf43922012-09-07 16:07:55 -04001317bool TWPartition::Is_Mounted(void) {
1318 if (!Can_Be_Mounted)
1319 return false;
1320
1321 struct stat st1, st2;
1322 string test_path;
1323
1324 // Check to see if the mount point directory exists
1325 test_path = Mount_Point + "/.";
1326 if (stat(test_path.c_str(), &st1) != 0) return false;
1327
1328 // Check to see if the directory above the mount point exists
1329 test_path = Mount_Point + "/../.";
1330 if (stat(test_path.c_str(), &st2) != 0) return false;
1331
1332 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1333 int ret = (st1.st_dev != st2.st_dev) ? true : false;
1334
1335 return ret;
1336}
1337
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001338bool TWPartition::Is_File_System_Writable(void) {
1339 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1340 return false;
1341
1342 string test_path = Mount_Point + "/.";
1343 return (access(test_path.c_str(), W_OK) == 0);
1344}
1345
Dees_Troy5bf43922012-09-07 16:07:55 -04001346bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001347 int exfat_mounted = 0;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001348 unsigned long flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001349
Dees_Troy5bf43922012-09-07 16:07:55 -04001350 if (Is_Mounted()) {
1351 return true;
1352 } else if (!Can_Be_Mounted) {
1353 return false;
1354 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001355
1356 Find_Actual_Block_Device();
1357
1358 // Check the current file system before mounting
1359 Check_FS_Type();
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001360 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
Dees_Troye34c1332013-02-06 19:13:00 +00001361 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 +00001362 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001363 string result;
1364 if (TWFunc::Exec_Cmd(cmd, result) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001365 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001366 Current_File_System = "vfat";
1367 } else {
1368#ifdef TW_NO_EXFAT_FUSE
1369 UnMount(false);
1370 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1371 // Some kernels let us mount vfat as exfat which doesn't work out too well
1372#else
1373 exfat_mounted = 1;
1374#endif
1375 }
1376 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001377
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001378 if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfs-3g") || TWFunc::Path_Exists("/sbin/mount.ntfs"))) {
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001379 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001380 string Ntfsmount_Binary = "";
1381
1382 if (TWFunc::Path_Exists("/sbin/ntfs-3g"))
1383 Ntfsmount_Binary = "ntfs-3g";
1384 else if (TWFunc::Path_Exists("/sbin/mount.ntfs"))
1385 Ntfsmount_Binary = "mount.ntfs";
1386
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001387 if (Mount_Read_Only)
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001388 cmd = "/sbin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001389 else
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001390 cmd = "/sbin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001391 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001392
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001393 if (TWFunc::Exec_Cmd(cmd) == 0) {
1394 return true;
1395 } else {
1396 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1397 }
1398 }
1399
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001400 if (Mount_Read_Only)
1401 flags |= MS_RDONLY;
1402
Dees_Troy22042032012-12-18 21:23:08 +00001403 if (Fstab_File_System == "yaffs2") {
1404 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001405 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1406 if (Mount_Read_Only)
1407 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001408 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1409 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1410 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001411 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001412 else
1413 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1414 return false;
1415 } else {
1416 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1417 return true;
1418 }
1419 } else {
1420 struct stat st;
1421 string test_path = Mount_Point;
1422 if (stat(test_path.c_str(), &st) < 0) {
1423 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001424 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001425 else
1426 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1427 return false;
1428 }
1429 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1430 if (new_mode != st.st_mode) {
1431 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1432 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1433 if (Display_Error)
1434 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1435 else
1436 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1437 return false;
1438 }
1439 }
Dees_Troy22042032012-12-18 21:23:08 +00001440 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001441 }
thatc7572eb2015-03-31 18:55:30 +02001442 }
1443
1444 string mount_fs = Current_File_System;
1445 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1446 mount_fs = "texfat";
1447
1448 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001449 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1450 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001451#ifdef TW_NO_EXFAT_FUSE
1452 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001453 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001454 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001455 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001456 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001457 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001458 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001459 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 +00001460 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001461 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001462 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001463#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001464 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001465 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001466 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001467 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1468 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 +00001469 return false;
1470#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001471 }
1472#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001473 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001474
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001475 if (Removable)
1476 Update_Size(Display_Error);
1477
xiaolu9416f4f2015-06-04 08:22:23 +08001478 if (!Symlink_Mount_Point.empty() && TWFunc::Path_Exists(Symlink_Path)) {
codelover2a3d4ce2015-03-14 20:26:49 +08001479 string Command = "mount -o bind '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
Vojtech Bocek05534202013-09-11 08:11:56 +02001480 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001481 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001482 return true;
1483}
1484
1485bool TWPartition::UnMount(bool Display_Error) {
1486 if (Is_Mounted()) {
1487 int never_unmount_system;
1488
1489 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
1490 if (never_unmount_system == 1 && Mount_Point == "/system")
1491 return true; // Never unmount system if you're not supposed to unmount it
1492
Matt Mowera8e6d832017-02-14 20:20:59 -06001493 if (Is_Storage && MTP_Storage_ID > 0)
Ethan Yonker726a0202014-12-16 20:01:38 -06001494 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001495
Dees_Troy38bd7602012-09-14 13:33:53 -04001496 if (!Symlink_Mount_Point.empty())
1497 umount(Symlink_Mount_Point.c_str());
1498
Dees_Troyb05ddee2013-01-28 20:24:50 +00001499 umount(Mount_Point.c_str());
1500 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001501 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001502 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001503 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001504 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001505 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001506 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001507 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001508 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001509 } else {
1510 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001511 }
1512}
1513
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001514bool TWPartition::ReMount(bool Display_Error) {
1515 if (UnMount(Display_Error))
1516 return Mount(Display_Error);
1517 return false;
1518}
1519
1520bool TWPartition::ReMount_RW(bool Display_Error) {
1521 // No need to remount if already mounted rw
1522 if (Is_File_System_Writable())
1523 return true;
1524
1525 bool ro = Mount_Read_Only;
1526 int flags = Mount_Flags;
1527
1528 Mount_Read_Only = false;
1529 Mount_Flags &= ~MS_RDONLY;
1530
1531 bool ret = ReMount(Display_Error);
1532
1533 Mount_Read_Only = ro;
1534 Mount_Flags = flags;
1535
1536 return ret;
1537}
1538
Gary Peck43acadf2012-11-21 21:19:01 -08001539bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001540 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001541 int check;
1542 string Layout_Filename = Mount_Point + "/.layout_version";
1543
Dees_Troy38bd7602012-09-14 13:33:53 -04001544 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001545 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001546 return false;
1547 }
1548
Dees_Troyc51f1f92012-09-20 15:32:13 -04001549 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001550 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001551
Dees_Troy16c2b312013-01-15 16:51:18 +00001552 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
1553 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
1554 else
1555 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -04001556
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001557 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001558 wiped = Wipe_Data_Without_Wiping_Media();
Ethan Yonker5eac2222014-06-11 12:22:55 -05001559 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001560 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001561 DataManager::GetValue(TW_RM_RF_VAR, check);
1562
Hashcodedabfd492013-08-29 22:45:30 -07001563 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001564 wiped = Wipe_RMRF();
1565 else if (New_File_System == "ext4")
1566 wiped = Wipe_EXT4();
1567 else if (New_File_System == "ext2" || New_File_System == "ext3")
1568 wiped = Wipe_EXT23(New_File_System);
1569 else if (New_File_System == "vfat")
1570 wiped = Wipe_FAT();
1571 else if (New_File_System == "exfat")
1572 wiped = Wipe_EXFAT();
1573 else if (New_File_System == "yaffs2")
1574 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001575 else if (New_File_System == "f2fs")
1576 wiped = Wipe_F2FS();
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001577 else if (New_File_System == "ntfs")
1578 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001579 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001580 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 +00001581 unlink("/.layout_version");
1582 return false;
1583 }
1584 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001585 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001586
Gary Pecke8bc5d72012-12-21 06:45:25 -08001587 if (wiped) {
Dees_Troy1c1ac442013-01-17 21:42:14 +00001588 if (Mount_Point == "/cache")
1589 DataManager::Output_Version();
1590
Dees_Troy16c2b312013-01-15 16:51:18 +00001591 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
1592 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
1593
1594 if (update_crypt) {
1595 Setup_File_System(false);
1596 if (Is_Encrypted && !Is_Decrypted) {
1597 // just wiped an encrypted partition back to its unencrypted state
1598 Is_Encrypted = false;
1599 Is_Decrypted = false;
1600 Decrypted_Block_Device = "";
1601 if (Mount_Point == "/data") {
1602 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1603 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1604 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001605 }
1606 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001607
Ethan Yonker66a19492015-12-10 10:19:45 -06001608 if (Has_Data_Media && recreate_media) {
Ethan Yonker5eac2222014-06-11 12:22:55 -05001609 Recreate_Media_Folder();
1610 }
Matt Mower209c9632016-01-20 12:08:35 -06001611 if (Is_Storage && Mount(false))
1612 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001613 }
Matt Mower209c9632016-01-20 12:08:35 -06001614
Gary Pecke8bc5d72012-12-21 06:45:25 -08001615 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001616}
1617
Gary Peck43acadf2012-11-21 21:19:01 -08001618bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001619 if (Is_File_System(Current_File_System))
1620 return Wipe(Current_File_System);
1621 else
1622 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001623}
1624
Dees_Troye58d5262012-09-21 12:27:57 -04001625bool TWPartition::Wipe_AndSec(void) {
1626 if (!Has_Android_Secure)
1627 return false;
1628
Dees_Troye58d5262012-09-21 12:27:57 -04001629 if (!Mount(true))
1630 return false;
1631
Ethan Yonker74db1572015-10-28 12:44:49 -05001632 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001633 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001634 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001635}
1636
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001637bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001638 if (Mount_Read_Only)
1639 return false;
Matt Mower18794c82015-11-11 16:22:45 -06001640 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/sbin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001641 return true;
1642 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/e2fsck"))
1643 return true;
1644 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/fsck.exfat"))
1645 return true;
1646 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/sbin/fsck.f2fs"))
1647 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001648 else if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfsfix") || TWFunc::Path_Exists("/sbin/fsck.ntfs")))
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001649 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001650 return false;
1651}
1652
1653bool TWPartition::Repair() {
1654 string command;
1655
1656 if (Current_File_System == "vfat") {
Matt Mower18794c82015-11-11 16:22:45 -06001657 if (!TWFunc::Path_Exists("/sbin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001658 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001659 return false;
1660 }
1661 if (!UnMount(true))
1662 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001663 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001664 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06001665 command = "/sbin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001666 LOGINFO("Repair command: %s\n", command.c_str());
1667 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001668 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001669 return true;
1670 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001671 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001672 return false;
1673 }
1674 }
1675 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1676 if (!TWFunc::Path_Exists("/sbin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001677 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001678 return false;
1679 }
1680 if (!UnMount(true))
1681 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001682 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001683 Find_Actual_Block_Device();
Ethan Yonkera2719152015-05-28 09:44:41 -05001684 command = "/sbin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001685 LOGINFO("Repair command: %s\n", command.c_str());
1686 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001687 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001688 return true;
1689 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001690 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001691 return false;
1692 }
1693 }
1694 if (Current_File_System == "exfat") {
1695 if (!TWFunc::Path_Exists("/sbin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001696 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001697 return false;
1698 }
1699 if (!UnMount(true))
1700 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001701 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001702 Find_Actual_Block_Device();
1703 command = "/sbin/fsck.exfat " + Actual_Block_Device;
1704 LOGINFO("Repair command: %s\n", command.c_str());
1705 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001706 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001707 return true;
1708 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001709 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001710 return false;
1711 }
1712 }
1713 if (Current_File_System == "f2fs") {
1714 if (!TWFunc::Path_Exists("/sbin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001715 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001716 return false;
1717 }
1718 if (!UnMount(true))
1719 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001720 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001721 Find_Actual_Block_Device();
1722 command = "/sbin/fsck.f2fs " + Actual_Block_Device;
1723 LOGINFO("Repair command: %s\n", command.c_str());
1724 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001725 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001726 return true;
1727 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001728 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001729 return false;
1730 }
1731 }
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001732 if (Current_File_System == "ntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001733 string Ntfsfix_Binary;
1734 if (TWFunc::Path_Exists("/sbin/ntfsfix"))
1735 Ntfsfix_Binary = "ntfsfix";
1736 else if (TWFunc::Path_Exists("/sbin/fsck.ntfs"))
1737 Ntfsfix_Binary = "fsck.ntfs";
1738 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001739 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001740 return false;
1741 }
1742 if (!UnMount(true))
1743 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001744 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001745 Find_Actual_Block_Device();
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001746 command = "/sbin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001747 LOGINFO("Repair command: %s\n", command.c_str());
1748 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001749 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001750 return true;
1751 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001752 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001753 return false;
1754 }
1755 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001756 return false;
1757}
1758
Ethan Yonkera2719152015-05-28 09:44:41 -05001759bool TWPartition::Can_Resize() {
1760 if (Mount_Read_Only)
1761 return false;
1762 if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/resize2fs"))
1763 return true;
1764 return false;
1765}
1766
1767bool TWPartition::Resize() {
1768 string command;
1769
1770 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1771 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001772 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1773 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001774 return false;
1775 }
1776 if (!TWFunc::Path_Exists("/sbin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001777 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1778 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001779 return false;
1780 }
1781 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001782 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001783 if (!Repair())
1784 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001785 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001786 Find_Actual_Block_Device();
1787 command = "/sbin/resize2fs " + Actual_Block_Device;
1788 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001789 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1790 if (Actual_Size == 0)
1791 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001792
Ethan Yonkera2719152015-05-28 09:44:41 -05001793 unsigned long long Block_Count;
1794 if (Length < 0) {
1795 // Reduce overall size by this length
1796 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1797 } else {
1798 // This is the size, not a size reduction
1799 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1800 }
1801 char temp[256];
1802 sprintf(temp, "%llu", Block_Count);
1803 command += " ";
1804 command += temp;
1805 command += "K";
1806 }
1807 LOGINFO("Resize command: %s\n", command.c_str());
1808 if (TWFunc::Exec_Cmd(command) == 0) {
1809 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001810 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001811 return true;
1812 } else {
1813 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001814 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001815 return false;
1816 }
1817 }
1818 return false;
1819}
1820
bigbiffce8f83c2015-12-12 18:30:21 -05001821bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
1822 if (Backup_Method == BM_FILES)
1823 return Backup_Tar(part_settings, tar_fork_pid);
1824 else if (Backup_Method == BM_DD)
1825 return Backup_Image(part_settings);
1826 else if (Backup_Method == BM_FLASH_UTILS)
1827 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00001828 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001829 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001830}
1831
bigbiffce8f83c2015-12-12 18:30:21 -05001832bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06001833 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonkere080c1f2016-09-19 13:50:25 -05001834 LOGINFO("Restore filename is: %s/%s\n", part_settings->Backup_Folder.c_str(), Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001835
bigbiffce8f83c2015-12-12 18:30:21 -05001836 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001837
1838 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05001839 return Restore_Tar(part_settings);
1840 else if (Is_Image(Restore_File_System))
1841 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001842
1843 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1844 return false;
1845}
1846
bigbiffce8f83c2015-12-12 18:30:21 -05001847string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001848 size_t first_period, second_period;
1849 string Restore_File_System;
1850
Gary Peck43acadf2012-11-21 21:19:01 -08001851 // Parse backup filename to extract the file system before wiping
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001852 first_period = Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08001853 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001854 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001855 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001856 }
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001857 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08001858 second_period = Restore_File_System.find(".");
1859 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001860 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001861 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001862 }
1863 Restore_File_System.resize(second_period);
Matt Mowera0cd91d2016-12-30 18:21:42 -06001864 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001865 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04001866}
1867
1868string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05001869 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04001870 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05001871 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04001872 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05001873 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04001874 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05001875 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04001876 return "flash_utils";
1877 else
1878 return "undefined";
1879 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04001880}
1881
1882bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001883 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001884 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04001885 return 1;
1886}
1887
1888bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001889 bool Save_Data_Media = Has_Data_Media;
1890
1891 if (!UnMount(true))
1892 return false;
1893
Dees_Troy38bd7602012-09-14 13:33:53 -04001894 Has_Data_Media = false;
Dees_Troy74fb2e92013-04-15 14:35:47 +00001895 Decrypted_Block_Device = "";
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001896#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker1b190162016-12-05 15:25:19 -06001897 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001898 if (!UnMount(true))
1899 return false;
Matt Mower2b18a532015-02-20 16:58:05 -06001900 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001901 LOGERR("Error deleting crypto block device, continuing anyway.\n");
1902 }
1903 }
1904#endif
Dees_Troy74fb2e92013-04-15 14:35:47 +00001905 Is_Decrypted = false;
1906 Is_Encrypted = false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001907 Find_Actual_Block_Device();
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001908 if (Crypto_Key_Location == "footer") {
1909 int newlen, fd;
1910 if (Length != 0) {
1911 newlen = Length;
1912 if (newlen < 0)
1913 newlen = newlen * -1;
1914 } else {
1915 newlen = CRYPT_FOOTER_OFFSET;
1916 }
1917 if ((fd = open(Actual_Block_Device.c_str(), O_RDWR)) < 0) {
1918 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
1919 } else {
1920 unsigned int block_count;
1921 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
1922 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
1923 } else {
1924 off64_t offset = ((off64_t)block_count * 512) - newlen;
1925 if (lseek64(fd, offset, SEEK_SET) == -1) {
1926 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
1927 } else {
1928 void* buffer = malloc(newlen);
1929 if (!buffer) {
1930 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
1931 } else {
1932 memset(buffer, 0, newlen);
1933 int ret = write(fd, buffer, newlen);
1934 if (ret != newlen) {
1935 gui_print_color("warning", "Failed to wipe crypto footer.\n");
1936 } else {
1937 LOGINFO("Successfully wiped crypto footer.\n");
1938 }
Matt Mower13a8f0b2015-09-26 15:40:03 -05001939 free(buffer);
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001940 }
1941 }
1942 }
1943 close(fd);
1944 }
1945 } else {
Ethan Yonkerc2dafbb2016-03-15 22:20:59 -05001946 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
1947 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
1948 TWFunc::Exec_Cmd(Command);
1949 } else {
1950 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
1951 }
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001952 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001953 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001954 Has_Data_Media = Save_Data_Media;
1955 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
1956 Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001957 if (Mount(false))
1958 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001959 }
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001960 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05001961#ifndef TW_OEM_BUILD
Ethan Yonker74db1572015-10-28 12:44:49 -05001962 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 -05001963#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001964 return true;
1965 } else {
1966 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05001967 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06001968 if (Has_Data_Media && Mount(false))
1969 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001970 return false;
1971 }
1972 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001973}
1974
1975void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001976 const char* type;
1977 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04001978
Dees_Troy68cab492012-12-12 19:29:35 +00001979 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1980 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001981
Dees_Troy38bd7602012-09-14 13:33:53 -04001982 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001983 if (!Is_Present)
1984 return;
Dees_Troy51127312012-09-08 13:08:49 -04001985
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001986 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
1987 if (blkid_do_fullprobe(pr)) {
1988 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001989 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001990 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001991 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001992
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001993 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001994 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001995 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001996 return;
1997 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001998
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001999 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02002000 blkid_free_probe(pr);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002001 if (fs_flags.size() > 1) {
2002 std::vector<partition_fs_flags_struct>::iterator iter;
2003 std::vector<partition_fs_flags_struct>::iterator found = fs_flags.begin();
2004
2005 for (iter = fs_flags.begin(); iter != fs_flags.end(); iter++) {
2006 if (iter->File_System == Current_File_System) {
2007 found = iter;
2008 break;
2009 }
2010 }
2011 // If we don't find a match, we default the flags to the first set of flags that we received from the fstab
2012 if (Mount_Flags != found->Mount_Flags || Mount_Options != found->Mount_Options) {
2013 Mount_Flags = found->Mount_Flags;
2014 Mount_Options = found->Mount_Options;
2015 LOGINFO("Mount_Flags: %i, Mount_Options: %s\n", Mount_Flags, Mount_Options.c_str());
2016 }
2017 }
Dees_Troy51a0e822012-09-05 15:24:24 -04002018}
2019
Gary Peck43acadf2012-11-21 21:19:01 -08002020bool TWPartition::Wipe_EXT23(string File_System) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002021 if (!UnMount(true))
2022 return false;
2023
Dees_Troy43d8b002012-09-17 16:00:01 -04002024 if (TWFunc::Path_Exists("/sbin/mke2fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002025 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002026
Greg Wallace4b44fef2015-12-29 15:33:24 -05002027 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002028 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002029 command = "mke2fs -t " + File_System + " -m 0 " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00002030 LOGINFO("mke2fs command: %s\n", command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002031 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002032 Current_File_System = File_System;
Dees_Troye58d5262012-09-21 12:27:57 -04002033 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002034 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002035 return true;
2036 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002037 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002038 return false;
2039 }
2040 } else
2041 return Wipe_RMRF();
2042
2043 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002044}
2045
2046bool TWPartition::Wipe_EXT4() {
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
Matt Mower87413642017-01-17 21:14:46 -06002056#if defined(USE_EXT4)
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002057 int ret;
2058 char *secontext = NULL;
2059
Greg Wallace4b44fef2015-12-29 15:33:24 -05002060 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002061
Dees Troy99c8dbf2014-03-10 16:53:58 +00002062 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06002063 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
2064 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), NULL);
2065 } else {
2066 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), selinux_handle);
2067 }
2068 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002069 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00002070 return false;
2071 } else {
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04002072 string sedir = Mount_Point + "/lost+found";
2073 PartitionManager.Mount_By_Path(sedir.c_str(), true);
2074 rmdir(sedir.c_str());
2075 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00002076 return true;
2077 }
2078#else
Dees_Troy43d8b002012-09-17 16:00:01 -04002079 if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002080 string Command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002081
Greg Wallace4b44fef2015-12-29 15:33:24 -05002082 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002083 Find_Actual_Block_Device();
2084 Command = "make_ext4fs";
2085 if (!Is_Decrypted && Length != 0) {
2086 // Only use length if we're not decrypted
2087 char len[32];
2088 sprintf(len, "%i", Length);
2089 Command += " -l ";
2090 Command += len;
2091 }
Dees_Troy5295d582013-09-06 15:51:08 +00002092 if (TWFunc::Path_Exists("/file_contexts")) {
2093 Command += " -S /file_contexts";
2094 }
2095 Command += " -a " + Mount_Point + " " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00002096 LOGINFO("make_ext4fs command: %s\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002097 if (TWFunc::Exec_Cmd(Command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002098 Current_File_System = "ext4";
Dees_Troye58d5262012-09-21 12:27:57 -04002099 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002100 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002101 return true;
2102 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002103 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002104 return false;
2105 }
2106 } else
Gary Peck43acadf2012-11-21 21:19:01 -08002107 return Wipe_EXT23("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00002108#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04002109 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002110}
2111
2112bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002113 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04002114
Matt Mower18794c82015-11-11 16:22:45 -06002115 if (TWFunc::Path_Exists("/sbin/mkfs.fat")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002116 if (!UnMount(true))
2117 return false;
2118
Greg Wallace4b44fef2015-12-29 15:33:24 -05002119 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002120 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06002121 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002122 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08002123 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04002124 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002125 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04002126 return true;
2127 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002128 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04002129 return false;
2130 }
2131 return true;
2132 }
2133 else
2134 return Wipe_RMRF();
2135
2136 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002137}
2138
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002139bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002140 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002141
2142 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
2143 if (!UnMount(true))
2144 return false;
2145
Greg Wallace4b44fef2015-12-29 15:33:24 -05002146 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002147 Find_Actual_Block_Device();
2148 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002149 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002150 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002151 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002152 return true;
2153 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002154 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002155 return false;
2156 }
2157 return true;
2158 }
2159 return false;
2160}
2161
Dees_Troy38bd7602012-09-14 13:33:53 -04002162bool TWPartition::Wipe_MTD() {
2163 if (!UnMount(true))
2164 return false;
2165
Greg Wallace4b44fef2015-12-29 15:33:24 -05002166 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04002167
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002168 mtd_scan_partitions();
2169 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
2170 if (mtd == NULL) {
2171 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
2172 return false;
2173 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002174
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002175 MtdWriteContext* ctx = mtd_write_partition(mtd);
2176 if (ctx == NULL) {
2177 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
2178 return false;
2179 }
2180 if (mtd_erase_blocks(ctx, -1) == -1) {
2181 mtd_write_close(ctx);
2182 LOGERR("Failed to format '%s'", MTD_Name.c_str());
2183 return false;
2184 }
2185 if (mtd_write_close(ctx) != 0) {
2186 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2187 return false;
2188 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002189 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002190 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002191 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002192 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002193}
2194
2195bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002196 if (!Mount(true))
2197 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002198 // This is the only wipe that leaves the partition mounted, so we
2199 // must manually remove the partition from MTP if it is a storage
2200 // partition.
2201 if (Is_Storage)
2202 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002203
Ethan Yonker74db1572015-10-28 12:44:49 -05002204 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002205 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002206 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002207 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002208}
2209
Dees_Troye5017042013-08-29 16:38:55 +00002210bool TWPartition::Wipe_F2FS() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002211 string command;
Dees_Troye5017042013-08-29 16:38:55 +00002212
2213 if (TWFunc::Path_Exists("/sbin/mkfs.f2fs")) {
2214 if (!UnMount(true))
2215 return false;
2216
Greg Wallace4b44fef2015-12-29 15:33:24 -05002217 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.f2fs"));
Dees_Troye5017042013-08-29 16:38:55 +00002218 Find_Actual_Block_Device();
Greg Wallace558aef72016-01-19 21:14:30 -05002219 command = "mkfs.f2fs -t 0";
dhacker29a3fa75f2015-01-17 19:42:33 -05002220 if (!Is_Decrypted && Length != 0) {
2221 // Only use length if we're not decrypted
2222 char len[32];
2223 int mod_length = Length;
2224 if (Length < 0)
2225 mod_length *= -1;
2226 sprintf(len, "%i", mod_length);
2227 command += " -r ";
2228 command += len;
2229 }
2230 command += " " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002231 if (TWFunc::Exec_Cmd(command) == 0) {
Dees_Troye5017042013-08-29 16:38:55 +00002232 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002233 gui_msg("done=Done.");
Dees_Troye5017042013-08-29 16:38:55 +00002234 return true;
2235 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002236 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troye5017042013-08-29 16:38:55 +00002237 return false;
2238 }
2239 return true;
2240 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002241 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002242 return Wipe_RMRF();
2243 }
2244 return false;
2245}
2246
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002247bool TWPartition::Wipe_NTFS() {
2248 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002249 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002250
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002251 if (TWFunc::Path_Exists("/sbin/mkntfs"))
2252 Ntfsmake_Binary = "mkntfs";
2253 else if (TWFunc::Path_Exists("/sbin/mkfs.ntfs"))
2254 Ntfsmake_Binary = "mkfs.ntfs";
2255 else
2256 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002257
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002258 if (!UnMount(true))
2259 return false;
2260
Greg Wallace4b44fef2015-12-29 15:33:24 -05002261 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002262 Find_Actual_Block_Device();
2263 command = "/sbin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
2264 if (TWFunc::Exec_Cmd(command) == 0) {
2265 Recreate_AndSec_Folder();
2266 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002267 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002268 } else {
2269 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2270 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002271 }
2272 return false;
2273}
2274
Dees_Troy51a0e822012-09-05 15:24:24 -04002275bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002276#ifdef TW_OEM_BUILD
2277 // In an OEM Build we want to do a full format
2278 return Wipe_Encryption();
2279#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002280 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002281
Dees_Troy38bd7602012-09-14 13:33:53 -04002282 if (!Mount(true))
2283 return false;
2284
Ethan Yonker74db1572015-10-28 12:44:49 -05002285 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002286 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2287 if (ret)
2288 gui_msg("done=Done.");
2289 return ret;
2290#endif // ifdef TW_OEM_BUILD
2291}
2292
2293bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2294 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002295
2296 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002297 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002298 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002299 struct dirent* de;
2300 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002301 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002302
Ethan Yonker66a19492015-12-10 10:19:45 -06002303 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002304 dir.append(de->d_name);
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002305 if (wipe_exclusions.check_skip_dirs(dir)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002306 LOGINFO("skipped '%s'\n", dir.c_str());
2307 continue;
2308 }
Dees_Troyce675462013-01-09 19:48:21 +00002309 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002310 dir.append("/");
2311 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2312 closedir(d);
2313 return false;
2314 }
2315 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002316 } 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 +03002317 if (unlink(dir.c_str()) != 0)
Ethan Yonker79f88bd2016-12-09 14:52:12 -06002318 LOGINFO("Unable to unlink '%s': %s\n", dir.c_str(), strerror(errno));
Dees_Troyce675462013-01-09 19:48:21 +00002319 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002320 }
2321 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002322
Dees_Troy16b74352012-11-14 22:27:31 +00002323 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002324 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002325 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002326 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002327}
2328
bigbiffce8f83c2015-12-12 18:30:21 -05002329bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002330 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002331 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002332
Dees_Troy43d8b002012-09-17 16:00:01 -04002333 if (!Mount(true))
2334 return false;
2335
Dees_Troya13d74f2013-03-24 08:54:55 -05002336 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, "Backing Up");
Ethan Yonker74db1572015-10-28 12:44:49 -05002337 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002338
Ethan Yonker472f5062016-02-25 13:47:30 -06002339 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002340
Dees_Troy83bd4832013-05-04 12:39:56 +00002341#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002342 if (Can_Encrypt_Backup) {
2343 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2344 if (tar.use_encryption) {
2345 if (Use_Userdata_Encryption)
2346 tar.userdata_encryption = tar.use_encryption;
2347 string Password;
2348 DataManager::GetValue("tw_backup_password", Password);
2349 tar.setpassword(Password);
2350 } else {
2351 tar.use_encryption = 0;
2352 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002353 }
2354#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002355
Ethan Yonker472f5062016-02-25 13:47:30 -06002356 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002357 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker01f4e032017-02-03 15:30:52 -06002358 if (Has_Data_Media)
2359 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 -05002360 tar.part_settings = part_settings;
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002361 tar.backup_exclusions = &backup_exclusions;
Dees Troye0a433a2013-12-02 04:10:37 +00002362 tar.setdir(Backup_Path);
2363 tar.setfn(Full_FileName);
2364 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002365 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002366 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002367 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002368 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002369 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002370}
2371
bigbiffce8f83c2015-12-12 18:30:21 -05002372bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2373 string Full_FileName, adb_file_name;
igoriok87e3d932013-01-31 21:03:53 +02002374
Ethan Yonker74db1572015-10-28 12:44:49 -05002375 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2376 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002377
Ethan Yonker472f5062016-02-25 13:47:30 -06002378 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002379
bigbiffce8f83c2015-12-12 18:30:21 -05002380 if (part_settings->adbbackup) {
2381 Full_FileName = TW_ADB_BACKUP;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002382 adb_file_name = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002383 }
2384 else
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002385 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002386
2387 part_settings->total_restore_size = Backup_Size;
2388
2389 if (part_settings->adbbackup) {
2390 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2391 return false;
2392 }
2393
2394 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002395 return false;
2396
bigbiffce8f83c2015-12-12 18:30:21 -05002397 if (part_settings->adbbackup) {
2398 if (!twadbbu::Write_TWEOF())
2399 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002400 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002401 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002402}
2403
bigbiffce8f83c2015-12-12 18:30:21 -05002404bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2405 unsigned long long RW_Block_Size, Remain = Backup_Size;
2406 int src_fd = -1, dest_fd = -1;
2407 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002408 bool ret = false;
2409 void* buffer = NULL;
2410 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002411 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002412
bigbiffce8f83c2015-12-12 18:30:21 -05002413 if (part_settings->PM_Method == PM_BACKUP) {
2414 srcfn = Actual_Block_Device;
2415 if (part_settings->adbbackup)
2416 destfn = TW_ADB_BACKUP;
2417 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002418 destfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002419 }
2420 else {
2421 destfn = Actual_Block_Device;
2422 if (part_settings->adbbackup) {
2423 srcfn = TW_ADB_RESTORE;
2424 } else {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002425 srcfn = part_settings->Backup_Folder + "/" + Backup_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002426 Remain = TWFunc::Get_File_Size(srcfn);
2427 }
2428 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002429
bigbiffce8f83c2015-12-12 18:30:21 -05002430 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002431 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002432 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002433 return false;
2434 }
bigbiffce8f83c2015-12-12 18:30:21 -05002435
2436 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 -06002437 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002438 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002439 goto exit;
2440 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002441
bigbiffce8f83c2015-12-12 18:30:21 -05002442 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2443
2444 if (part_settings->adbbackup) {
2445 RW_Block_Size = MAX_ADB_READ;
2446 bs = MAX_ADB_READ;
2447 }
2448 else {
2449 RW_Block_Size = 1048576LLU; // 1MB
2450 bs = (ssize_t)(RW_Block_Size);
2451 }
2452
Ethan Yonker472f5062016-02-25 13:47:30 -06002453 buffer = malloc((size_t)bs);
2454 if (!buffer) {
2455 LOGINFO("Raw_Read_Write failed to malloc\n");
2456 goto exit;
2457 }
bigbiffce8f83c2015-12-12 18:30:21 -05002458
2459 if (part_settings->progress)
2460 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2461
Ethan Yonker472f5062016-02-25 13:47:30 -06002462 while (Remain > 0) {
2463 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002464 bs = (ssize_t)(Remain);
Matt Mowera8a89d12016-12-30 18:10:37 -06002465 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002466 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2467 goto exit;
2468 }
2469 if (write(dest_fd, buffer, bs) != bs) {
2470 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2471 goto exit;
2472 }
2473 backedup_size += (unsigned long long)(bs);
Matt Mower029a82d2017-01-08 13:12:38 -06002474 Remain -= (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002475 if (part_settings->progress)
2476 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002477 if (PartitionManager.Check_Backup_Cancel() != 0)
2478 goto exit;
2479 }
bigbiffce8f83c2015-12-12 18:30:21 -05002480 if (part_settings->progress)
2481 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002482 fsync(dest_fd);
nailyka083dc62016-11-11 21:41:28 +01002483
2484 if (!part_settings->adbbackup && part_settings->PM_Method == PM_BACKUP) {
2485 tw_set_default_metadata(destfn.c_str());
2486 LOGINFO("Restored default metadata for %s\n", destfn.c_str());
2487 }
2488
Ethan Yonker472f5062016-02-25 13:47:30 -06002489 ret = true;
2490exit:
2491 if (src_fd >= 0)
2492 close(src_fd);
2493 if (dest_fd >= 0)
2494 close(dest_fd);
2495 if (buffer)
2496 free(buffer);
2497 return ret;
2498}
2499
bigbiffce8f83c2015-12-12 18:30:21 -05002500bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002501 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002502
Ethan Yonker74db1572015-10-28 12:44:49 -05002503 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2504 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002505
bigbiffce8f83c2015-12-12 18:30:21 -05002506 if (part_settings->progress)
2507 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002508
Ethan Yonker472f5062016-02-25 13:47:30 -06002509 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002510 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002511
2512 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002513
Dees_Troy2673cec2013-04-02 20:22:16 +00002514 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002515 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002516 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002517 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2518 // 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 -06002519 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002520 return false;
2521 }
bigbiffce8f83c2015-12-12 18:30:21 -05002522 if (part_settings->progress)
2523 part_settings->progress->UpdateSize(Backup_Size);
2524
Dees_Troy43d8b002012-09-17 16:00:01 -04002525 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002526}
2527
bigbiffce8f83c2015-12-12 18:30:21 -05002528unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2529 if (!part_settings->adbbackup) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002530 InfoManager restore_info(part_settings->Backup_Folder + "/" + Backup_Name + ".info");
bigbiffce8f83c2015-12-12 18:30:21 -05002531 if (restore_info.LoadValues() == 0) {
2532 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2533 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2534 return Restore_Size;
2535 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002536 }
2537 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002538
Matt Mower029a82d2017-01-08 13:12:38 -06002539 string Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
2540 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002541
2542 if (Is_Image(Restore_File_System)) {
2543 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2544 return Restore_Size;
2545 }
2546
2547 twrpTar tar;
2548 tar.setdir(Backup_Path);
2549 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002550 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002551#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2552 string Password;
2553 DataManager::GetValue("tw_restore_password", Password);
2554 if (!Password.empty())
2555 tar.setpassword(Password);
2556#endif
2557 tar.partition_name = Backup_Name;
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002558 tar.backup_folder = part_settings->Backup_Folder;
bigbiffce8f83c2015-12-12 18:30:21 -05002559 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002560 Restore_Size = tar.get_size();
2561 return Restore_Size;
2562}
2563
bigbiffce8f83c2015-12-12 18:30:21 -05002564bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002565 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002566 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002567 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002568
Dees_Troye58d5262012-09-21 12:27:57 -04002569 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002570 if (!Wipe_AndSec())
2571 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002572 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002573 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002574 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002575 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 -05002576 if (!Wipe_Data_Without_Wiping_Media())
2577 return false;
2578 } else {
2579 if (!Wipe(Restore_File_System))
2580 return false;
2581 }
Dees_Troye58d5262012-09-21 12:27:57 -04002582 }
Matt Mower3c366972015-12-25 19:28:31 -06002583 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002584 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002585
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002586 // Remount as read/write as needed so we can restore the backup
2587 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002588 return false;
2589
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002590 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002591 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002592 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002593 tar.setdir(Backup_Path);
2594 tar.setfn(Full_FileName);
2595 tar.backup_name = Backup_Name;
2596#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2597 string Password;
2598 DataManager::GetValue("tw_restore_password", Password);
2599 if (!Password.empty())
2600 tar.setpassword(Password);
2601#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002602 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2603 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002604 ret = false;
2605 else
2606 ret = true;
2607#ifdef HAVE_CAPABILITIES
2608 // Restore capabilities to the run-as binary
2609 if (Mount_Point == "/system" && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
2610 struct vfs_cap_data cap_data;
2611 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2612
2613 memset(&cap_data, 0, sizeof(cap_data));
2614 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2615 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2616 cap_data.data[0].inheritable = 0;
2617 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2618 cap_data.data[1].inheritable = 0;
2619 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2620 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2621 } else {
2622 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2623 }
2624 }
2625#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002626 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2627 // Remount as read only when restoration is complete
2628 ReMount(true);
2629
Dees Troy4159aed2014-02-28 17:24:43 +00002630 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002631}
2632
bigbiffce8f83c2015-12-12 18:30:21 -05002633bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002634 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002635 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002636
Matt Mower3c366972015-12-25 19:28:31 -06002637 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002638 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002639
2640 if (part_settings->adbbackup)
2641 Full_FileName = TW_ADB_RESTORE;
2642 else
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002643 Full_FileName = part_settings->Backup_Folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002644
Ethan Yonker96af84a2015-01-05 14:58:36 -06002645 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002646 if (!part_settings->adbbackup)
2647 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2648 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002649 return false;
2650 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002651 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2652 return false;
2653 }
2654
2655 if (part_settings->adbbackup) {
2656 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002657 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002658 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002659 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002660}
Dees_Troy5bf43922012-09-07 16:07:55 -04002661
2662bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002663 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002664
Ethan Yonker1b190162016-12-05 15:25:19 -06002665 Find_Actual_Block_Device();
2666
2667 if (!Can_Be_Mounted && !Is_Encrypted) {
2668 if (TWFunc::Path_Exists(Actual_Block_Device) && Find_Partition_Size()) {
2669 Used = Size;
2670 Backup_Size = Size;
2671 return true;
2672 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002673 return false;
Ethan Yonker1b190162016-12-05 15:25:19 -06002674 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002675
Dees_Troy0550cfb2012-10-13 11:56:13 -04002676 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04002677 if (Removable || Is_Encrypted) {
2678 if (!Mount(false))
2679 return true;
2680 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002681 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002682
2683 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002684 if (!ret || Size == 0) {
2685 if (!Get_Size_Via_df(Display_Error)) {
2686 if (!Was_Already_Mounted)
2687 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002688 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002689 }
2690 }
Dees_Troy51127312012-09-08 13:08:49 -04002691
Dees_Troy5bf43922012-09-07 16:07:55 -04002692 if (Has_Data_Media) {
2693 if (Mount(Display_Error)) {
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002694 Used = backup_exclusions.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002695 Backup_Size = Used;
2696 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04002697 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002698 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002699 } else {
2700 if (!Was_Already_Mounted)
2701 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002702 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002703 }
Dees_Troye58d5262012-09-21 12:27:57 -04002704 } else if (Has_Android_Secure) {
2705 if (Mount(Display_Error))
Ethan Yonker3fdcda42016-11-30 12:29:37 -06002706 Backup_Size = backup_exclusions.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002707 else {
2708 if (!Was_Already_Mounted)
2709 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04002710 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002711 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002712 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04002713 if (!Was_Already_Mounted)
2714 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002715 return true;
Dees_Troy51127312012-09-08 13:08:49 -04002716}
Dees_Troy38bd7602012-09-14 13:33:53 -04002717
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002718bool TWPartition::Find_Wildcard_Block_Devices(const string& Device) {
2719 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
2720 string Path = TWFunc::Get_Path(Device);
2721 string Dev = TWFunc::Get_Filename(Device);
2722 size_t wildcard_index = Dev.find("*");
2723 if (wildcard_index != string::npos)
2724 Dev = Dev.substr(0, wildcard_index);
2725 wildcard_index = Dev.size();
2726 DIR* d = opendir(Path.c_str());
2727 if (d == NULL) {
2728 LOGINFO("Error opening '%s': %s\n", Path.c_str(), strerror(errno));
2729 return false;
2730 }
2731 struct dirent* de;
2732 while ((de = readdir(d)) != NULL) {
2733 if (de->d_type != DT_BLK || strlen(de->d_name) <= wildcard_index || strncmp(de->d_name, Dev.c_str(), wildcard_index) != 0)
2734 continue;
2735
2736 string item = Path + "/";
2737 item.append(de->d_name);
2738 if (PartitionManager.Find_Partition_By_Block_Device(item))
2739 continue;
2740 TWPartition *part = new TWPartition;
2741 char buffer[MAX_FSTAB_LINE_LENGTH];
2742 sprintf(buffer, "%s %s-%i auto defaults defaults", item.c_str(), Mount_Point.c_str(), ++mount_point_index);
2743 part->Process_Fstab_Line(buffer, false, NULL);
2744 char display[MAX_FSTAB_LINE_LENGTH];
2745 sprintf(display, "%s %i", Storage_Name.c_str(), mount_point_index);
2746 part->Storage_Name = display;
2747 part->Display_Name = display;
2748 part->Primary_Block_Device = item;
2749 part->Wildcard_Block_Device = false;
2750 part->Is_SubPartition = true;
2751 part->SubPartition_Of = Mount_Point;
2752 part->Is_Storage = Is_Storage;
2753 part->Can_Be_Mounted = true;
2754 part->Removable = true;
2755 part->Can_Be_Wiped = Can_Be_Wiped;
2756 part->Wipe_Available_in_GUI = Wipe_Available_in_GUI;
2757 part->Find_Actual_Block_Device();
2758 part->Update_Size(false);
2759 Has_SubPartition = true;
2760 PartitionManager.Output_Partition(part);
2761 PartitionManager.Add_Partition(part);
2762 }
2763 closedir(d);
2764 return (mount_point_index > 0);
2765}
2766
Dees_Troy38bd7602012-09-14 13:33:53 -04002767void TWPartition::Find_Actual_Block_Device(void) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002768 if (!Sysfs_Entry.empty() && Primary_Block_Device.empty() && Decrypted_Block_Device.empty()) {
2769 /* Sysfs_Entry.empty() indicates if this is a sysfs entry that begins with /device/
2770 * If we have a syfs entry then we are looking for this device from a uevent add.
2771 * The uevent add will set the primary block device based on the data we receive from
2772 * after checking for adopted storage. If the device ends up being adopted, then the
2773 * decrypted block device will be set instead of the primary block device. */
2774 Is_Present = false;
2775 return;
2776 }
2777 if (Wildcard_Block_Device && !Is_Adopted_Storage) {
2778 Is_Present = false;
2779 Actual_Block_Device = "";
2780 Can_Be_Mounted = false;
2781 if (!Find_Wildcard_Block_Devices(Primary_Block_Device)) {
2782 string Dev = Primary_Block_Device.substr(0, Primary_Block_Device.find("*"));
2783 if (TWFunc::Path_Exists(Dev)) {
2784 Is_Present = true;
2785 Can_Be_Mounted = true;
2786 Actual_Block_Device = Dev;
2787 }
2788 }
2789 return;
2790 } else if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002791 Actual_Block_Device = Decrypted_Block_Device;
Ethan Yonker1b190162016-12-05 15:25:19 -06002792 if (TWFunc::Path_Exists(Decrypted_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002793 Is_Present = true;
Ethan Yonker1b190162016-12-05 15:25:19 -06002794 return;
2795 }
2796 } else if (SlotSelect && TWFunc::Path_Exists(Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix())) {
2797 Actual_Block_Device = Primary_Block_Device + PartitionManager.Get_Active_Slot_Suffix();
2798 unlink(Primary_Block_Device.c_str());
2799 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
2800 Is_Present = true;
2801 return;
Dees_Troy43d8b002012-09-17 16:00:01 -04002802 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002803 Is_Present = true;
2804 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002805 return;
2806 }
Ethan Yonker1b190162016-12-05 15:25:19 -06002807 if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04002808 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04002809 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002810 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04002811 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002812 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002813}
2814
2815void TWPartition::Recreate_Media_Folder(void) {
2816 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06002817 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04002818
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06002819 if (Is_FBE) {
2820 LOGINFO("Not recreating media folder on FBE\n");
2821 return;
2822 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002823 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002824 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
2825 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002826 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06002827 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
2828 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08002829 string Internal_path = DataManager::GetStrValue("tw_internal_path");
2830 if (!Internal_path.empty()) {
2831 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
2832 mkdir(Internal_path.c_str(), 0770);
2833 }
2834#ifdef TW_INTERNAL_STORAGE_PATH
2835 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
2836#endif
Matt Mower87413642017-01-17 21:14:46 -06002837
thata3d31fb2014-12-21 22:27:40 +01002838 // Afterwards, we will try to set the
2839 // default metadata that we were hopefully able to get during
2840 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06002841 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08002842 if (!Internal_path.empty())
2843 tw_set_default_metadata(Internal_path.c_str());
Matt Mower87413642017-01-17 21:14:46 -06002844
Ethan Yonker5eac2222014-06-11 12:22:55 -05002845 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002846 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05002847 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04002848 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002849}
Dees_Troye58d5262012-09-21 12:27:57 -04002850
2851void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04002852 if (!Has_Android_Secure)
2853 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00002854 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002855 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002856 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04002857 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002858 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002859 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002860 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002861 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002862 }
2863}
bigbiff7cb4c332014-11-26 20:36:07 -05002864
2865uint64_t TWPartition::Get_Max_FileSize() {
2866 uint64_t maxFileSize = 0;
2867 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
2868 const uint64_t constTB = (uint64_t) constGB * 1024;
2869 const uint64_t constPB = (uint64_t) constTB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05002870 if (Current_File_System == "ext4")
2871 maxFileSize = 16 * constTB; //16 TB
2872 else if (Current_File_System == "vfat")
2873 maxFileSize = 4 * constGB; //4 GB
2874 else if (Current_File_System == "ntfs")
2875 maxFileSize = 256 * constTB; //256 TB
2876 else if (Current_File_System == "exfat")
2877 maxFileSize = 16 * constPB; //16 PB
2878 else if (Current_File_System == "ext3")
2879 maxFileSize = 2 * constTB; //2 TB
2880 else if (Current_File_System == "f2fs")
2881 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05002882 else
2883 maxFileSize = 100000000L;
2884 return maxFileSize - 1;
2885}
2886
bigbiffce8f83c2015-12-12 18:30:21 -05002887bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
2888 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002889
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002890 full_filename = part_settings->Backup_Folder + "/" + Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002891
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002892 LOGINFO("Image filename is: %s\n", Backup_FileName.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -05002893
2894 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002895 LOGERR("Cannot flash images to file systems\n");
2896 return false;
2897 } else if (!Can_Flash_Img) {
2898 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
2899 return false;
2900 } else {
2901 if (!Find_Partition_Size()) {
2902 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
2903 return false;
2904 }
bigbiffce8f83c2015-12-12 18:30:21 -05002905 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06002906 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002907 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05002908 image_size, Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05002909 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002910 return false;
2911 }
bigbiffce8f83c2015-12-12 18:30:21 -05002912 if (Backup_Method == BM_DD) {
2913 if (!part_settings->adbbackup) {
2914 if (Is_Sparse_Image(full_filename)) {
2915 return Flash_Sparse_Image(full_filename);
2916 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002917 }
bigbiffce8f83c2015-12-12 18:30:21 -05002918 return Raw_Read_Write(part_settings);
2919 } else if (Backup_Method == BM_FLASH_UTILS) {
2920 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06002921 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002922 }
2923
2924 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
2925 return false;
2926}
2927
Ethan Yonker472f5062016-02-25 13:47:30 -06002928bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05002929 uint32_t magic = 0;
2930 int fd = open(Filename.c_str(), O_RDONLY);
2931 if (fd < 0) {
2932 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
2933 return false;
2934 }
bigbiffce8f83c2015-12-12 18:30:21 -05002935
HashBanged974bb2016-01-30 14:20:09 -05002936 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
2937 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
2938 close(fd);
2939 return false;
2940 }
2941 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06002942 if (magic == SPARSE_HEADER_MAGIC)
2943 return true;
2944 return false;
2945}
2946
2947bool TWPartition::Flash_Sparse_Image(const string& Filename) {
2948 string Command;
2949
2950 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
2951
2952 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06002953 LOGINFO("Flash command: '%s'\n", Command.c_str());
2954 TWFunc::Exec_Cmd(Command);
2955 return true;
2956}
2957
Ethan Yonker472f5062016-02-25 13:47:30 -06002958bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002959 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06002960 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002961
Ethan Yonker74db1572015-10-28 12:44:49 -05002962 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06002963 if (progress) {
2964 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
2965 progress->SetPartitionSize(file_size);
2966 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002967 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
2968 Command = "erase_image " + MTD_Name;
2969 LOGINFO("Erase command: '%s'\n", Command.c_str());
2970 TWFunc::Exec_Cmd(Command);
2971 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
2972 LOGINFO("Flash command: '%s'\n", Command.c_str());
2973 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06002974 if (progress)
2975 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06002976 return true;
2977}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05002978
2979void TWPartition::Change_Mount_Read_Only(bool new_value) {
2980 Mount_Read_Only = new_value;
2981}
2982
bigbiffce8f83c2015-12-12 18:30:21 -05002983bool TWPartition::Is_Read_Only() {
2984 return Mount_Read_Only;
2985}
2986
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05002987int TWPartition::Check_Lifetime_Writes() {
2988 bool original_read_only = Mount_Read_Only;
2989 int ret = 1;
2990
2991 Mount_Read_Only = true;
2992 if (Mount(false)) {
2993 Find_Actual_Block_Device();
2994 string block = basename(Actual_Block_Device.c_str());
2995 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
2996 string result;
2997 if (TWFunc::Path_Exists(file)) {
2998 if (TWFunc::read_file(file, result) != 0) {
2999 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
3000 } else {
3001 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
3002 if (result == "0") {
3003 ret = 0;
3004 }
3005 }
3006 } else {
3007 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
3008 }
3009 UnMount(true);
3010 } else {
3011 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
3012 }
3013 Mount_Read_Only = original_read_only;
3014 return ret;
3015}
Ethan Yonker66a19492015-12-10 10:19:45 -06003016
3017int TWPartition::Decrypt_Adopted() {
3018#ifdef TW_INCLUDE_CRYPTO
3019 int ret = 1;
3020 Is_Adopted_Storage = false;
3021 string Adopted_Key_File = "";
3022
3023 if (!Removable)
3024 return ret;
3025
3026 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
3027 if (fd < 0) {
3028 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
3029 return ret;
3030 }
3031 char type_guid[80];
3032 char part_guid[80];
3033
3034 if (gpt_disk_get_partition_info(fd, 2, type_guid, part_guid) == 0) {
3035 LOGINFO("type: '%s'\n", type_guid);
3036 LOGINFO("part: '%s'\n", part_guid);
3037 Adopted_GUID = part_guid;
3038 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
3039 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
3040 LOGINFO("android_expand found\n");
3041 Adopted_Key_File = "/data/misc/vold/expand_";
3042 Adopted_Key_File += part_guid;
3043 Adopted_Key_File += ".key";
3044 if (TWFunc::Path_Exists(Adopted_Key_File)) {
3045 Is_Adopted_Storage = true;
3046 /* Until we find a use case for this, I think it is safe
3047 * to disable USB Mass Storage whenever adopted storage
3048 * is present.
3049 */
3050 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
3051 DataManager::SetValue("tw_has_usb_storage", 0);
3052 }
3053 }
3054 }
3055
3056 if (Is_Adopted_Storage) {
3057 string Adopted_Block_Device = Alternate_Block_Device + "p2";
3058 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3059 Adopted_Block_Device = Alternate_Block_Device + "2";
3060 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
3061 LOGINFO("Adopted block device does not exist\n");
3062 goto exit;
3063 }
3064 }
3065 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
3066 char crypto_blkdev[MAXPATHLEN];
3067 std::string thekey;
3068 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
3069 if (fdkey < 0) {
3070 LOGINFO("failed to open key file\n");
3071 goto exit;
3072 }
3073 char buf[512];
3074 ssize_t n;
3075 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
3076 thekey.append(buf, n);
3077 }
3078 close(fdkey);
3079 unsigned char* key = (unsigned char*) thekey.data();
3080 cryptfs_revert_ext_volume(part_guid);
3081
3082 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
3083 if (ret == 0) {
3084 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
3085 Decrypted_Block_Device = crypto_blkdev;
3086 Is_Decrypted = true;
3087 Is_Encrypted = true;
3088 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00003089 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06003090 LOGERR("Failed to mount decrypted adopted storage device\n");
3091 Is_Decrypted = false;
3092 Is_Encrypted = false;
3093 cryptfs_revert_ext_volume(part_guid);
3094 ret = 1;
3095 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06003096 UnMount(false);
3097 Has_Android_Secure = false;
3098 Symlink_Path = "";
3099 Symlink_Mount_Point = "";
3100 Backup_Name = Mount_Point.substr(1);
3101 Backup_Path = Mount_Point;
3102 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
3103 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
3104 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
3105 PartitionManager.Remove_Partition_By_Path("/sd-ext");
3106 }
Ethan Yonker66a19492015-12-10 10:19:45 -06003107 Setup_Data_Media();
3108 Recreate_Media_Folder();
3109 Wipe_Available_in_GUI = true;
3110 Wipe_During_Factory_Reset = true;
3111 Can_Be_Backed_Up = true;
3112 Can_Encrypt_Backup = true;
3113 Use_Userdata_Encryption = true;
3114 Is_Storage = true;
3115 Storage_Name = "Adopted Storage";
3116 Is_SubPartition = true;
3117 SubPartition_Of = "/data";
3118 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
3119 DataManager::SetValue("tw_has_adopted_storage", 1);
3120 }
3121 } else {
3122 LOGERR("Failed to setup adopted storage decryption\n");
3123 }
3124 }
3125exit:
Matt Mower06543e32017-01-06 15:25:26 -06003126 close(fd);
Ethan Yonker66a19492015-12-10 10:19:45 -06003127 return ret;
3128#else
3129 LOGINFO("Decrypt_Adopted: no crypto support\n");
3130 return 1;
3131#endif
3132}
3133
3134void TWPartition::Revert_Adopted() {
3135#ifdef TW_INCLUDE_CRYPTO
3136 if (!Adopted_GUID.empty()) {
3137 PartitionManager.Remove_MTP_Storage(Mount_Point);
3138 UnMount(false);
3139 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
3140 Is_Adopted_Storage = false;
3141 Is_Encrypted = false;
3142 Is_Decrypted = false;
3143 Decrypted_Block_Device = "";
3144 Find_Actual_Block_Device();
3145 Wipe_During_Factory_Reset = false;
3146 Can_Be_Backed_Up = false;
3147 Can_Encrypt_Backup = false;
3148 Use_Userdata_Encryption = false;
3149 Is_SubPartition = false;
3150 SubPartition_Of = "";
3151 Has_Data_Media = false;
3152 Storage_Path = Mount_Point;
3153 if (!Symlink_Mount_Point.empty()) {
3154 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
3155 if (Dat) {
3156 Dat->UnMount(false);
3157 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
3158 }
3159 Symlink_Mount_Point = "";
3160 }
3161 }
3162#else
3163 LOGINFO("Revert_Adopted: no crypto support\n");
3164#endif
3165}
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -04003166
3167void TWPartition::Set_Backup_FileName(string fname) {
3168 Backup_FileName = fname;
3169}
3170
3171string TWPartition::Get_Backup_Name() {
3172 return Backup_Name;
3173}