blob: 0272708cd07abda7c18f8d19cf432dba3916c4fc [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 -0500