blob: 89650db6cc216e522b3798d7f1f5806420a6891c [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
Ethan Yonker472f5062016-02-25 13:47:30 -06002 Copyright 2013 to 2016 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 bigbiffcdcfee42013-02-27 21:11:26 -050044#include "twrpDigest.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050045#include "twrpTar.hpp"
bigbiff bigbiff34684ff2013-12-01 21:03:45 -050046#include "twrpDU.hpp"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050047#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060048#include "set_metadata.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050049#include "gui/gui.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050050#include "adbbu/libtwadbbu.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040051extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040052 #include "mtdutils/mtdutils.h"
53 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000054#ifdef USE_EXT4
55 #include "make_ext4fs.h"
56#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 Yonkerbc85b632015-08-09 12:48:14 -050061#else
62 #define CRYPT_FOOTER_OFFSET 0x4000
Ethan Yonker71413f42014-02-26 13:36:08 -060063#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040064}
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040065#ifdef HAVE_SELINUX
66#include "selinux/selinux.h"
Ethan Yonkerf27497f2014-02-09 11:48:33 -060067#include <selinux/label.h>
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040068#endif
Dees Troy4159aed2014-02-28 17:24:43 +000069#ifdef HAVE_CAPABILITIES
70#include <sys/capability.h>
71#include <sys/xattr.h>
72#include <linux/xattr.h>
73#endif
HashBanged974bb2016-01-30 14:20:09 -050074#include <sparse_format.h>
Ethan Yonker472f5062016-02-25 13:47:30 -060075#include "progresstracking.hpp"
Dees_Troy51a0e822012-09-05 15:24:24 -040076
bigbiff bigbiff9c754052013-01-09 09:09:08 -050077using namespace std;
78
Dees_Troya95f55c2013-08-17 13:14:43 +000079extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050080extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000081
Hashcode62bd9e02013-11-19 21:59:42 -080082struct flag_list {
83 const char *name;
84 unsigned flag;
85};
86
Matt Mower4ab42b12016-04-21 13:52:18 -050087const struct flag_list mount_flags[] = {
Hashcode62bd9e02013-11-19 21:59:42 -080088 { "noatime", MS_NOATIME },
89 { "noexec", MS_NOEXEC },
90 { "nosuid", MS_NOSUID },
91 { "nodev", MS_NODEV },
92 { "nodiratime", MS_NODIRATIME },
93 { "ro", MS_RDONLY },
94 { "rw", 0 },
95 { "remount", MS_REMOUNT },
96 { "bind", MS_BIND },
97 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +000098#ifdef MS_UNBINDABLE
Hashcode62bd9e02013-11-19 21:59:42 -080099 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000100#endif
101#ifdef MS_PRIVATE
Hashcode62bd9e02013-11-19 21:59:42 -0800102 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000103#endif
104#ifdef MS_SLAVE
Hashcode62bd9e02013-11-19 21:59:42 -0800105 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000106#endif
107#ifdef MS_SHARED
Hashcode62bd9e02013-11-19 21:59:42 -0800108 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000109#endif
Hashcode62bd9e02013-11-19 21:59:42 -0800110 { "sync", MS_SYNCHRONOUS },
111 { "defaults", 0 },
112 { 0, 0 },
113};
114
Matt Mower2416a502016-04-12 19:54:46 -0500115enum TW_FSTAB_FLAGS {
116 TWFLAG_DEFAULTS, // Retain position
117 TWFLAG_ANDSEC,
118 TWFLAG_BACKUP,
119 TWFLAG_BACKUPNAME,
120 TWFLAG_BLOCKSIZE,
121 TWFLAG_CANBEWIPED,
122 TWFLAG_CANENCRYPTBACKUP,
123 TWFLAG_DISPLAY,
124 TWFLAG_ENCRYPTABLE,
125 TWFLAG_FLASHIMG,
126 TWFLAG_FORCEENCRYPT,
127 TWFLAG_FSFLAGS,
128 TWFLAG_IGNOREBLKID,
129 TWFLAG_LENGTH,
130 TWFLAG_MOUNTTODECRYPT,
131 TWFLAG_REMOVABLE,
132 TWFLAG_RETAINLAYOUTVERSION,
133 TWFLAG_SETTINGSSTORAGE,
134 TWFLAG_STORAGE,
135 TWFLAG_STORAGENAME,
136 TWFLAG_SUBPARTITIONOF,
137 TWFLAG_SYMLINK,
138 TWFLAG_USERDATAENCRYPTBACKUP,
139 TWFLAG_USERMRF,
140 TWFLAG_WIPEDURINGFACTORYRESET,
141 TWFLAG_WIPEINGUI,
142};
143
144/* Flags without a trailing '=' are considered dual format flags and can be
145 * written as either 'flagname' or 'flagname=', where the character following
146 * the '=' is Y,y,1 for true and false otherwise.
147 */
148const struct flag_list tw_flags[] = {
149 { "andsec", TWFLAG_ANDSEC },
150 { "backup", TWFLAG_BACKUP },
151 { "backupname=", TWFLAG_BACKUPNAME },
152 { "blocksize=", TWFLAG_BLOCKSIZE },
153 { "canbewiped", TWFLAG_CANBEWIPED },
154 { "canencryptbackup", TWFLAG_CANENCRYPTBACKUP },
155 { "defaults", TWFLAG_DEFAULTS },
156 { "display=", TWFLAG_DISPLAY },
157 { "encryptable=", TWFLAG_ENCRYPTABLE },
158 { "flashimg", TWFLAG_FLASHIMG },
159 { "forceencrypt=", TWFLAG_FORCEENCRYPT },
160 { "fsflags=", TWFLAG_FSFLAGS },
161 { "ignoreblkid", TWFLAG_IGNOREBLKID },
162 { "length=", TWFLAG_LENGTH },
163 { "mounttodecrypt", TWFLAG_MOUNTTODECRYPT },
164 { "removable", TWFLAG_REMOVABLE },
165 { "retainlayoutversion", TWFLAG_RETAINLAYOUTVERSION },
166 { "settingsstorage", TWFLAG_SETTINGSSTORAGE },
167 { "storage", TWFLAG_STORAGE },
168 { "storagename=", TWFLAG_STORAGENAME },
169 { "subpartitionof=", TWFLAG_SUBPARTITIONOF },
170 { "symlink=", TWFLAG_SYMLINK },
171 { "userdataencryptbackup", TWFLAG_USERDATAENCRYPTBACKUP },
172 { "usermrf", TWFLAG_USERMRF },
173 { "wipeduringfactoryreset", TWFLAG_WIPEDURINGFACTORYRESET },
174 { "wipeingui", TWFLAG_WIPEINGUI },
175 { 0, 0 },
176};
177
that9e0593e2014-10-08 00:01:24 +0200178TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400179 Can_Be_Mounted = false;
180 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500181 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200182 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400183 Wipe_During_Factory_Reset = false;
184 Wipe_Available_in_GUI = false;
185 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400186 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400187 SubPartition_Of = "";
188 Symlink_Path = "";
189 Symlink_Mount_Point = "";
190 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400191 Backup_Path = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400192 Actual_Block_Device = "";
193 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400194 Alternate_Block_Device = "";
195 Removable = false;
196 Is_Present = false;
197 Length = 0;
198 Size = 0;
199 Used = 0;
200 Free = 0;
201 Backup_Size = 0;
202 Can_Be_Encrypted = false;
203 Is_Encrypted = false;
204 Is_Decrypted = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600205 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400206 Decrypted_Block_Device = "";
207 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500208 Backup_Display_Name = "";
209 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400210 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400211 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400212 MTD_Name = "";
bigbiffce8f83c2015-12-12 18:30:21 -0500213 Backup_Method = BM_NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000214 Can_Encrypt_Backup = false;
215 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400216 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400217 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400218 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500219 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400220 Storage_Path = "";
221 Current_File_System = "";
222 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800223 Mount_Flags = 0;
224 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400225 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000226 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +0000227 Retain_Layout_Version = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600228 Crypto_Key_Location = "footer";
Ethan Yonker726a0202014-12-16 20:01:38 -0600229 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600230 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500231 Mount_Read_Only = false;
Ethan Yonker66a19492015-12-10 10:19:45 -0600232 Is_Adopted_Storage = false;
233 Adopted_GUID = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400234}
235
236TWPartition::~TWPartition(void) {
237 // Do nothing
238}
239
Matt Mower2b2dd152016-04-26 11:24:08 -0500240bool TWPartition::Process_Fstab_Line(const char *fstab_line, bool Display_Error) {
241 char full_line[MAX_FSTAB_LINE_LENGTH];
Matt Mower2416a502016-04-12 19:54:46 -0500242 char twflags[MAX_FSTAB_LINE_LENGTH] = "";
Dees_Troy5bf43922012-09-07 16:07:55 -0400243 char* ptr;
Matt Mower2b2dd152016-04-26 11:24:08 -0500244 int line_len = strlen(fstab_line), index = 0, item_index = 0;
Dees_Troya13d74f2013-03-24 08:54:55 -0500245 bool skip = false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400246
Matt Mower2b2dd152016-04-26 11:24:08 -0500247 strlcpy(full_line, fstab_line, sizeof(full_line));
Dees_Troy51127312012-09-08 13:08:49 -0400248 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500249 if (full_line[index] == 34)
250 skip = !skip;
251 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400252 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400253 }
Dees_Troy7c2dec82012-09-26 09:49:14 -0400254 Mount_Point = full_line;
Dees_Troy2673cec2013-04-02 20:22:16 +0000255 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -0400256 Backup_Path = Mount_Point;
Dees_Troya13d74f2013-03-24 08:54:55 -0500257 Storage_Path = Mount_Point;
Dees_Troy70737fa2013-04-08 13:19:20 +0000258 Display_Name = full_line + 1;
259 Backup_Display_Name = Display_Name;
260 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400261 index = Mount_Point.size();
262 while (index < line_len) {
263 while (index < line_len && full_line[index] == '\0')
264 index++;
265 if (index >= line_len)
266 continue;
267 ptr = full_line + index;
268 if (item_index == 0) {
269 // File System
270 Fstab_File_System = ptr;
271 Current_File_System = ptr;
272 item_index++;
273 } else if (item_index == 1) {
274 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400275 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400276 MTD_Name = ptr;
277 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400278 } else if (Fstab_File_System == "bml") {
279 if (Mount_Point == "/boot")
280 MTD_Name = "boot";
281 else if (Mount_Point == "/recovery")
282 MTD_Name = "recovery";
283 Primary_Block_Device = ptr;
284 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000285 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 -0400286 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400287 if (Display_Error)
Matt Mower2b2dd152016-04-26 11:24:08 -0500288 LOGERR("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400289 else
Matt Mower2b2dd152016-04-26 11:24:08 -0500290 LOGINFO("Invalid block device '%s' in fstab line '%s'", ptr, fstab_line);
Matt Mower72c87ce2016-04-26 14:34:56 -0500291 return false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400292 } else {
293 Primary_Block_Device = ptr;
294 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400295 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400296 item_index++;
297 } else if (item_index > 1) {
298 if (*ptr == '/') {
299 // Alternate Block Device
300 Alternate_Block_Device = ptr;
301 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
302 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
303 // Partition length
304 ptr += 7;
305 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400306 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
307 // Custom flags, save for later so that new values aren't overwritten by defaults
308 ptr += 6;
Matt Mower2416a502016-04-12 19:54:46 -0500309 strlcpy(twflags, ptr, sizeof(twflags));
Dees_Troy38bd7602012-09-14 13:33:53 -0400310 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
311 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400312 } else {
313 // Unhandled data
Matt Mower2b2dd152016-04-26 11:24:08 -0500314 LOGINFO("Unhandled fstab information '%s' in fstab line '%s'\n", ptr, fstab_line);
Dees_Troy5bf43922012-09-07 16:07:55 -0400315 }
316 }
317 while (index < line_len && full_line[index] != '\0')
318 index++;
319 }
320
321 if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
322 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000323 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400324 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000325 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Matt Mower72c87ce2016-04-26 14:34:56 -0500326 return false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400327 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400328 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400329 Setup_File_System(Display_Error);
330 if (Mount_Point == "/system") {
331 Display_Name = "System";
Dees_Troya13d74f2013-03-24 08:54:55 -0500332 Backup_Display_Name = Display_Name;
333 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400334 Wipe_Available_in_GUI = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500335 Can_Be_Backed_Up = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500336 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400337 } else if (Mount_Point == "/data") {
338 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500339 Backup_Display_Name = Display_Name;
340 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400341 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400342 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500343 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000344 Can_Encrypt_Backup = true;
345 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400346 } else if (Mount_Point == "/cache") {
347 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500348 Backup_Display_Name = Display_Name;
349 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400350 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400351 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500352 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400353 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400354 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400355 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500356 Backup_Display_Name = Display_Name;
357 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400358 Is_SubPartition = true;
359 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400360 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500361 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000362 Can_Encrypt_Backup = true;
363 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400364 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400365 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400366 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500367 Backup_Display_Name = Display_Name;
368 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400369 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400370 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500371 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000372 Can_Encrypt_Backup = true;
373 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400374 } else if (Mount_Point == "/boot") {
375 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500376 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400377 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500378 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500379 } else if (Mount_Point == "/vendor") {
380 Display_Name = "Vendor";
381 Backup_Display_Name = Display_Name;
382 Storage_Name = Display_Name;
383 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400384 }
385#ifdef TW_EXTERNAL_STORAGE_PATH
386 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
387 Is_Storage = true;
388 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400389 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500390 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400391#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000392 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400393 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400394 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500395 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400396#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000397 }
Dees_Troy8170a922012-09-18 15:40:25 -0400398#ifdef TW_INTERNAL_STORAGE_PATH
399 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
400 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500401 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400402 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500403 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400404 }
405#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000406 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400407 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500408 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500409 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400410 }
411#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400412 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400413 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400414 Setup_Image(Display_Error);
Dees_Troya13d74f2013-03-24 08:54:55 -0500415 if (Mount_Point == "/boot") {
416 Display_Name = "Boot";
417 Backup_Display_Name = Display_Name;
418 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600419 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500420 } else if (Mount_Point == "/recovery") {
421 Display_Name = "Recovery";
422 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600423 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500424 } else if (Mount_Point == "/system_image") {
425 Display_Name = "System Image";
426 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500427 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500428 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500429 } else if (Mount_Point == "/vendor_image") {
430 Display_Name = "Vendor Image";
431 Backup_Display_Name = Display_Name;
HashBanged974bb2016-01-30 14:20:09 -0500432 Can_Flash_Img = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500433 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500434 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400435 }
436
Matt Mower2416a502016-04-12 19:54:46 -0500437 // Process TWRP fstab flags
438 if (strlen(twflags) > 0) {
439 string Prev_Display_Name = Display_Name;
440 string Prev_Storage_Name = Storage_Name;
441 string Prev_Backup_Display_Name = Backup_Display_Name;
442 Display_Name = "";
443 Storage_Name = "";
444 Backup_Display_Name = "";
445
446 Process_TW_Flags(twflags, Display_Error);
447
448 bool has_display_name = !Display_Name.empty();
449 bool has_storage_name = !Storage_Name.empty();
450 bool has_backup_name = !Backup_Display_Name.empty();
451 if (!has_display_name) Display_Name = Prev_Display_Name;
452 if (!has_storage_name) Storage_Name = Prev_Storage_Name;
453 if (!has_backup_name) Backup_Display_Name = Prev_Backup_Display_Name;
454
455 if (has_display_name && !has_storage_name)
456 Storage_Name = Display_Name;
457 if (!has_display_name && has_storage_name)
458 Display_Name = Storage_Name;
459 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
460 Backup_Display_Name = Display_Name;
461 if (!has_display_name && has_backup_name)
462 Display_Name = Backup_Display_Name;
463 }
Dees_Troy51127312012-09-08 13:08:49 -0400464 return true;
465}
466
Matt Mower72c87ce2016-04-26 14:34:56 -0500467void TWPartition::Partition_Post_Processing(bool Display_Error) {
468 if (Mount_Point == "/data")
469 Setup_Data_Partition(Display_Error);
470 else if (Mount_Point == "/cache")
471 Setup_Cache_Partition(Display_Error);
472}
473
474void TWPartition::Setup_Data_Partition(bool Display_Error) {
475 if (Mount_Point != "/data")
476 return;
477
478 // Ensure /data is not mounted as tmpfs for qcom hardware decrypt
479 UnMount(false);
480
481#ifdef TW_INCLUDE_CRYPTO
482 if (datamedia)
483 Setup_Data_Media();
484 Can_Be_Encrypted = true;
485 char crypto_blkdev[255];
486 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
487 if (strcmp(crypto_blkdev, "error") != 0) {
488 DataManager::SetValue(TW_IS_DECRYPTED, 1);
489 Is_Encrypted = true;
490 Is_Decrypted = true;
491 Decrypted_Block_Device = crypto_blkdev;
492 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
493 } else if (!Mount(false)) {
494 if (Is_Present) {
495 set_partition_data(Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(), Fstab_File_System.c_str());
496 if (cryptfs_check_footer() == 0) {
497 Is_Encrypted = true;
498 Is_Decrypted = false;
499 Can_Be_Mounted = false;
500 Current_File_System = "emmc";
501 Setup_Image(Display_Error);
502 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
503 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
504 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
505 DataManager::SetValue("tw_crypto_display", "");
506 } else {
507 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
508 }
509 } else {
510 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
511 }
512 } else {
513 // Filesystem is not encrypted and the mount succeeded, so return to
514 // the original unmounted state
515 UnMount(false);
516 }
517 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))) {
518 Setup_Data_Media();
519 Recreate_Media_Folder();
520 }
521#else
522 if (datamedia) {
523 Setup_Data_Media();
524 Recreate_Media_Folder();
525 }
526#endif
527}
528
529void TWPartition::Setup_Cache_Partition(bool Display_Error __unused) {
530 if (Mount_Point != "/cache")
531 return;
532
533 if (!Mount(true))
534 return;
535
536 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
537 LOGINFO("Recreating /cache/recovery folder\n");
538 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
539 LOGERR("Could not create /cache/recovery\n");
540 }
541}
542
Matt Mower4ab42b12016-04-21 13:52:18 -0500543void TWPartition::Process_FS_Flags(const char *str) {
544 char *options = strdup(str);
545 char *ptr, *savep;
Hashcode62bd9e02013-11-19 21:59:42 -0800546
Matt Mower4ab42b12016-04-21 13:52:18 -0500547 Mount_Options = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800548
Matt Mower4ab42b12016-04-21 13:52:18 -0500549 // Avoid issues with potentially nested strtok by using strtok_r
550 ptr = strtok_r(options, ",", &savep);
551 while (ptr) {
552 const struct flag_list* mount_flag = mount_flags;
553
554 for (; mount_flag->name; mount_flag++) {
555 // mount_flags are never postfixed by '=',
556 // so only match identical strings (including length)
557 if (strcmp(ptr, mount_flag->name) == 0) {
558 Mount_Flags |= mount_flag->flag;
Hashcode62bd9e02013-11-19 21:59:42 -0800559 break;
560 }
561 }
562
Matt Mower4ab42b12016-04-21 13:52:18 -0500563 if (mount_flag->flag == MS_RDONLY)
564 Mount_Read_Only = true;
Hashcode62bd9e02013-11-19 21:59:42 -0800565
Matt Mower4ab42b12016-04-21 13:52:18 -0500566 if (mount_flag->name != 0) {
567 if (!Mount_Options.empty())
568 Mount_Options += ",";
569 Mount_Options += mount_flag->name;
570 } else {
571 LOGINFO("Unhandled mount flag: '%s'\n", ptr);
572 }
573
574 ptr = strtok_r(NULL, ",", &savep);
575 }
576 free(options);
Hashcode62bd9e02013-11-19 21:59:42 -0800577}
578
Matt Mower2416a502016-04-12 19:54:46 -0500579void TWPartition::Apply_TW_Flag(const unsigned flag, const char* str, const bool val) {
580 switch (flag) {
581 case TWFLAG_ANDSEC:
582 Has_Android_Secure = val;
583 break;
584 case TWFLAG_BACKUP:
585 Can_Be_Backed_Up = val;
586 break;
587 case TWFLAG_BACKUPNAME:
588 Backup_Display_Name = str;
589 break;
590 case TWFLAG_BLOCKSIZE:
591 Format_Block_Size = (unsigned long)(atol(str));
592 break;
593 case TWFLAG_CANBEWIPED:
594 Can_Be_Wiped = val;
595 break;
596 case TWFLAG_CANENCRYPTBACKUP:
597 Can_Encrypt_Backup = val;
598 break;
599 case TWFLAG_DEFAULTS:
600 // Do nothing
601 break;
602 case TWFLAG_DISPLAY:
603 Display_Name = str;
604 break;
605 case TWFLAG_ENCRYPTABLE:
606 case TWFLAG_FORCEENCRYPT:
607 Crypto_Key_Location = str;
608 break;
609 case TWFLAG_FLASHIMG:
610 Can_Flash_Img = val;
611 break;
612 case TWFLAG_FSFLAGS:
Matt Mower4ab42b12016-04-21 13:52:18 -0500613 Process_FS_Flags(str);
Matt Mower2416a502016-04-12 19:54:46 -0500614 break;
615 case TWFLAG_IGNOREBLKID:
616 Ignore_Blkid = val;
617 break;
618 case TWFLAG_LENGTH:
619 Length = atoi(str);
620 break;
621 case TWFLAG_MOUNTTODECRYPT:
622 Mount_To_Decrypt = val;
623 break;
624 case TWFLAG_REMOVABLE:
625 Removable = val;
626 break;
627 case TWFLAG_RETAINLAYOUTVERSION:
628 Retain_Layout_Version = val;
629 break;
630 case TWFLAG_SETTINGSSTORAGE:
631 Is_Settings_Storage = val;
632 if (Is_Settings_Storage)
633 Is_Storage = true;
634 break;
635 case TWFLAG_STORAGE:
636 Is_Storage = val;
637 break;
638 case TWFLAG_STORAGENAME:
639 Storage_Name = str;
640 break;
641 case TWFLAG_SUBPARTITIONOF:
642 Is_SubPartition = true;
643 SubPartition_Of = str;
644 break;
645 case TWFLAG_SYMLINK:
646 Symlink_Path = str;
647 break;
648 case TWFLAG_USERDATAENCRYPTBACKUP:
649 Use_Userdata_Encryption = val;
650 if (Use_Userdata_Encryption)
651 Can_Encrypt_Backup = true;
652 break;
653 case TWFLAG_USERMRF:
654 Use_Rm_Rf = val;
655 break;
656 case TWFLAG_WIPEDURINGFACTORYRESET:
657 Wipe_During_Factory_Reset = val;
658 if (Wipe_During_Factory_Reset) {
659 Can_Be_Wiped = true;
660 Wipe_Available_in_GUI = true;
661 }
662 break;
663 case TWFLAG_WIPEINGUI:
664 Wipe_Available_in_GUI = val;
665 if (Wipe_Available_in_GUI)
666 Can_Be_Wiped = true;
667 break;
668 default:
669 // Should not get here
670 LOGINFO("Flag identified for processing, but later unmatched: %i\n", flag);
671 break;
672 }
673}
Dees_Troy51127312012-09-08 13:08:49 -0400674
Matt Mower2416a502016-04-12 19:54:46 -0500675void TWPartition::Process_TW_Flags(char *flags, bool Display_Error) {
676 char separator[2] = {'\n', 0};
677 char *ptr, *savep;
678
679 // Semicolons within double-quotes are not forbidden, so replace
680 // only the semicolons intended as separators with '\n' for strtok
681 for (unsigned i = 0, skip = 0; i < strlen(flags); i++) {
682 if (flags[i] == '\"')
Dees_Troya13d74f2013-03-24 08:54:55 -0500683 skip = !skip;
Matt Mower2416a502016-04-12 19:54:46 -0500684 if (!skip && flags[i] == ';')
685 flags[i] = separator[0];
Dees_Troy51127312012-09-08 13:08:49 -0400686 }
687
Matt Mower2416a502016-04-12 19:54:46 -0500688 // Avoid issues with potentially nested strtok by using strtok_r
689 ptr = strtok_r(flags, separator, &savep);
690 while (ptr) {
691 int ptr_len = strlen(ptr);
692 const struct flag_list* tw_flag = tw_flags;
Hashcode62bd9e02013-11-19 21:59:42 -0800693
Matt Mower2416a502016-04-12 19:54:46 -0500694 for (; tw_flag->name; tw_flag++) {
695 int flag_len = strlen(tw_flag->name);
696
697 if (strncmp(ptr, tw_flag->name, flag_len) == 0) {
698 bool flag_val = false;
699
700 if (ptr_len > flag_len && (tw_flag->name)[flag_len-1] != '='
701 && ptr[flag_len] != '=') {
702 // Handle flags with same starting string
703 // (e.g. backup and backupname)
704 continue;
705 } else if (ptr_len > flag_len && ptr[flag_len] == '=') {
706 // Handle flags with dual format: Part 1
707 // (e.g. backup and backup=y. backup=y handled here)
708 ptr += flag_len + 1;
709 TWFunc::Strip_Quotes(ptr);
710 // Skip flags with empty argument
711 // (e.g. backup=)
712 if (strlen(ptr) == 0) {
713 LOGINFO("Flag missing argument or should not include '=': %s=\n", tw_flag->name);
714 break;
715 }
716 flag_val = strchr("yY1", *ptr) != NULL;
717 } else if (ptr_len == flag_len
718 && (tw_flag->name)[flag_len-1] == '=') {
719 // Skip flags missing argument after =
720 // (e.g. backupname=)
721 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
722 break;
723 } else if (ptr_len > flag_len
724 && (tw_flag->name)[flag_len-1] == '=') {
725 // Handle arguments to flags
726 // (e.g. backupname="My Stuff")
727 ptr += flag_len;
728 TWFunc::Strip_Quotes(ptr);
729 // Skip flags with empty argument
730 // (e.g. backupname="")
731 if (strlen(ptr) == 0) {
732 LOGINFO("Flag missing argument: %s\n", tw_flag->name);
733 break;
734 }
735 } else if (ptr_len == flag_len) {
736 // Handle flags with dual format: Part 2
737 // (e.g. backup and backup=y. backup handled here)
738 flag_val = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600739 } else {
Matt Mower2416a502016-04-12 19:54:46 -0500740 LOGINFO("Flag matched, but could not be processed: %s\n", ptr);
741 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600742 }
Matt Mower2416a502016-04-12 19:54:46 -0500743
744 Apply_TW_Flag(tw_flag->flag, ptr, flag_val);
745 break;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600746 }
Matt Mower2416a502016-04-12 19:54:46 -0500747 }
748 if (tw_flag->name == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400749 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000750 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400751 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000752 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400753 }
Matt Mower2416a502016-04-12 19:54:46 -0500754 ptr = strtok_r(NULL, separator, &savep);
Dees_Troy51127312012-09-08 13:08:49 -0400755 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400756}
757
Dees_Troy5bf43922012-09-07 16:07:55 -0400758bool TWPartition::Is_File_System(string File_System) {
759 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -0400760 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400761 File_System == "ext4" ||
762 File_System == "vfat" ||
763 File_System == "ntfs" ||
764 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -0500765 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +0000766 File_System == "f2fs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400767 File_System == "auto")
768 return true;
769 else
770 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400771}
772
Dees_Troy5bf43922012-09-07 16:07:55 -0400773bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400774 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400775 return true;
776 else
777 return false;
778}
779
Dees_Troy51127312012-09-08 13:08:49 -0400780bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400781 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400782 if (mkdir(Path.c_str(), 0777) == -1) {
783 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -0500784 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -0400785 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000786 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400787 return false;
788 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000789 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400790 return true;
791 }
792 }
793 return true;
794}
795
Dees_Troy5bf43922012-09-07 16:07:55 -0400796void TWPartition::Setup_File_System(bool Display_Error) {
797 struct statfs st;
798
799 Can_Be_Mounted = true;
800 Can_Be_Wiped = true;
801
Dees_Troy5bf43922012-09-07 16:07:55 -0400802 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -0400803 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400804 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
805 Backup_Name = Display_Name;
bigbiffce8f83c2015-12-12 18:30:21 -0500806 Backup_Method = BM_FILES;
Dees_Troy5bf43922012-09-07 16:07:55 -0400807}
808
809void TWPartition::Setup_Image(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400810 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
811 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -0800812 if (Current_File_System == "emmc")
bigbiffce8f83c2015-12-12 18:30:21 -0500813 Backup_Method = BM_DD;
Gary Peck82599a82012-11-21 16:23:12 -0800814 else if (Current_File_System == "mtd" || Current_File_System == "bml")
bigbiffce8f83c2015-12-12 18:30:21 -0500815 Backup_Method = BM_FLASH_UTILS;
Dees_Troy5bf43922012-09-07 16:07:55 -0400816 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000817 LOGINFO("Unhandled file system '%s' on image '%s'\n", Current_File_System.c_str(), Display_Name.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400818 if (Find_Partition_Size()) {
819 Used = Size;
820 Backup_Size = Size;
Dees_Troy51a0e822012-09-05 15:24:24 -0400821 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400822 if (Display_Error)
Dees Troyd932ce12013-10-18 17:12:59 +0000823 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400824 else
Dees Troyd932ce12013-10-18 17:12:59 +0000825 LOGINFO("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -0400826 }
827}
828
Dees_Troye58d5262012-09-21 12:27:57 -0400829void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500830 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -0400831 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -0500832 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -0400833 Has_Android_Secure = true;
834 Symlink_Path = Mount_Point + "/.android_secure";
835 Symlink_Mount_Point = "/and-sec";
836 Backup_Path = Symlink_Mount_Point;
837 Make_Dir("/and-sec", true);
838 Recreate_AndSec_Folder();
Kjell Braden3126a112016-06-19 16:58:15 +0000839 Mount_Storage_Retry(true);
Dees_Troye58d5262012-09-21 12:27:57 -0400840}
841
that9e0593e2014-10-08 00:01:24 +0200842void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -0500843 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Ethan Yonker66a19492015-12-10 10:19:45 -0600844 if (Storage_Name.empty() || Storage_Name == "Data")
845 Storage_Name = "Internal Storage";
Ethan Yonker6277c792014-09-15 14:54:30 -0500846 Has_Data_Media = true;
847 Is_Storage = true;
Ethan Yonker66a19492015-12-10 10:19:45 -0600848 Storage_Path = Mount_Point + "/media";
Ethan Yonker6277c792014-09-15 14:54:30 -0500849 Symlink_Path = Storage_Path;
Ethan Yonker66a19492015-12-10 10:19:45 -0600850 if (Mount_Point == "/data") {
851 Is_Settings_Storage = true;
852 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
853 Make_Dir("/emmc", false);
854 Symlink_Mount_Point = "/emmc";
855 } else {
856 Make_Dir("/sdcard", false);
857 Symlink_Mount_Point = "/sdcard";
858 }
859 if (Mount(false) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
860 Storage_Path = Mount_Point + "/media/0";
861 Symlink_Path = Storage_Path;
862 DataManager::SetValue(TW_INTERNAL_PATH, Mount_Point + "/media/0");
863 UnMount(true);
864 }
865 DataManager::SetValue("tw_has_internal", 1);
866 DataManager::SetValue("tw_has_data_media", 1);
867 du.add_absolute_dir(Mount_Point + "/misc/vold");
868 du.add_absolute_dir(Mount_Point + "/.layout_version");
869 du.add_absolute_dir(Mount_Point + "/system/storage.xml");
Ethan Yonker6277c792014-09-15 14:54:30 -0500870 } else {
Ethan Yonker66a19492015-12-10 10:19:45 -0600871 if (Mount(true) && TWFunc::Path_Exists(Mount_Point + "/media/0")) {
872 Storage_Path = Mount_Point + "/media/0";
873 Symlink_Path = Storage_Path;
874 UnMount(true);
875 }
Ethan Yonker6277c792014-09-15 14:54:30 -0500876 }
Ethan Yonker66a19492015-12-10 10:19:45 -0600877 du.add_absolute_dir(Mount_Point + "/media");
Ethan Yonker6277c792014-09-15 14:54:30 -0500878}
879
Dees_Troy5bf43922012-09-07 16:07:55 -0400880void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
881 char device[512], realDevice[512];
882
883 strcpy(device, Block.c_str());
884 memset(realDevice, 0, sizeof(realDevice));
885 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
886 {
887 strcpy(device, realDevice);
888 memset(realDevice, 0, sizeof(realDevice));
889 }
890
891 if (device[0] != '/') {
892 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000893 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400894 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000895 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400896 return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400897 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400898 Block = device;
899 return;
900 }
901}
902
Kjell Braden3126a112016-06-19 16:58:15 +0000903bool TWPartition::Mount_Storage_Retry(bool Display_Error) {
Dees_Troy8e337f32012-10-13 22:07:49 -0400904 // On some devices, storage doesn't want to mount right away, retry and sleep
Kjell Braden3126a112016-06-19 16:58:15 +0000905 if (!Mount(Display_Error)) {
Dees_Troy8e337f32012-10-13 22:07:49 -0400906 int retry_count = 5;
907 while (retry_count > 0 && !Mount(false)) {
908 usleep(500000);
909 retry_count--;
910 }
Kjell Braden3126a112016-06-19 16:58:15 +0000911 return Mount(Display_Error);
Dees_Troy8e337f32012-10-13 22:07:49 -0400912 }
Kjell Braden3126a112016-06-19 16:58:15 +0000913 return true;
Dees_Troy8e337f32012-10-13 22:07:49 -0400914}
915
Dees_Troy38bd7602012-09-14 13:33:53 -0400916bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
917 FILE *fp = NULL;
918 char line[255];
919
920 fp = fopen("/proc/mtd", "rt");
921 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000922 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400923 return false;
924 }
925
926 while (fgets(line, sizeof(line), fp) != NULL)
927 {
928 char device[32], label[32];
929 unsigned long size = 0;
930 char* fstype = NULL;
931 int deviceId;
932
933 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
934
935 // Skip header and blank lines
936 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
937 continue;
938
939 // Strip off the trailing " from the label
940 label[strlen(label)-1] = '\0';
941
942 if (strcmp(label, MTD_Name.c_str()) == 0) {
943 // We found our device
944 // Strip off the trailing : from the device
945 device[strlen(device)-1] = '\0';
946 if (sscanf(device,"mtd%d", &deviceId) == 1) {
947 sprintf(device, "/dev/block/mtdblock%d", deviceId);
948 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +0000949 fclose(fp);
950 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -0400951 }
952 }
953 }
954 fclose(fp);
955
956 return false;
957}
958
Dees_Troy51127312012-09-08 13:08:49 -0400959bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
960 struct statfs st;
961 string Local_Path = Mount_Point + "/.";
962
963 if (!Mount(Display_Error))
964 return false;
965
966 if (statfs(Local_Path.c_str(), &st) != 0) {
967 if (!Removable) {
968 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000969 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400970 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000971 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400972 }
973 return false;
974 }
975 Size = (st.f_blocks * st.f_bsize);
976 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
977 Free = (st.f_bfree * st.f_bsize);
978 Backup_Size = Used;
979 return true;
980}
981
982bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400983 FILE* fp;
984 char command[255], line[512];
985 int include_block = 1;
986 unsigned int min_len;
987
988 if (!Mount(Display_Error))
989 return false;
990
Dees_Troy38bd7602012-09-14 13:33:53 -0400991 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -0400992 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +0200993 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -0400994 fp = fopen("/tmp/dfoutput.txt", "rt");
995 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000996 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400997 return false;
Dees_Troy51127312012-09-08 13:08:49 -0400998 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400999
1000 while (fgets(line, sizeof(line), fp) != NULL)
1001 {
1002 unsigned long blocks, used, available;
1003 char device[64];
1004 char tmpString[64];
1005
1006 if (strncmp(line, "Filesystem", 10) == 0)
1007 continue;
1008 if (strlen(line) < min_len) {
1009 include_block = 0;
1010 continue;
1011 }
1012 if (include_block) {
1013 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
1014 } else {
1015 // The device block string is so long that the df information is on the next line
1016 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -04001017 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001018 while (tmpString[space_count] == 32)
1019 space_count++;
1020 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
1021 }
1022
1023 // Adjust block size to byte size
1024 Size = blocks * 1024ULL;
1025 Used = used * 1024ULL;
1026 Free = available * 1024ULL;
1027 Backup_Size = Used;
1028 }
1029 fclose(fp);
1030 return true;
1031}
1032
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001033unsigned long long TWPartition::IOCTL_Get_Block_Size() {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001034 Find_Actual_Block_Device();
Ethan Yonker483e9f42016-01-11 22:21:18 -06001035
1036 return TWFunc::IOCTL_Get_Block_Size(Actual_Block_Device.c_str());
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001037}
1038
Dees_Troy5bf43922012-09-07 16:07:55 -04001039bool TWPartition::Find_Partition_Size(void) {
1040 FILE* fp;
1041 char line[512];
1042 string tmpdevice;
1043
igoriok87e3d932013-01-31 21:03:53 +02001044 fp = fopen("/proc/dumchar_info", "rt");
1045 if (fp != NULL) {
1046 while (fgets(line, sizeof(line), fp) != NULL)
1047 {
1048 char label[32], device[32];
1049 unsigned long size = 0;
1050
thatd43bf2d2014-09-21 23:13:02 +02001051 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +02001052
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001053 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +02001054 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
1055 continue;
1056
1057 tmpdevice = "/dev/";
1058 tmpdevice += label;
1059 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
1060 Size = size;
1061 fclose(fp);
1062 return true;
1063 }
1064 }
1065 }
1066
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001067 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
1068 if (ioctl_size) {
1069 Size = ioctl_size;
1070 return true;
1071 }
1072
Dees_Troy5bf43922012-09-07 16:07:55 -04001073 // In this case, we'll first get the partitions we care about (with labels)
1074 fp = fopen("/proc/partitions", "rt");
1075 if (fp == NULL)
1076 return false;
1077
1078 while (fgets(line, sizeof(line), fp) != NULL)
1079 {
1080 unsigned long major, minor, blocks;
1081 char device[512];
1082 char tmpString[64];
1083
Dees_Troy63c8df72012-09-10 14:02:05 -04001084 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001085 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
1086
1087 tmpdevice = "/dev/block/";
1088 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001089 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001090 // Adjust block size to byte size
1091 Size = blocks * 1024ULL;
1092 fclose(fp);
1093 return true;
1094 }
1095 }
1096 fclose(fp);
1097 return false;
1098}
1099
Dees_Troy5bf43922012-09-07 16:07:55 -04001100bool TWPartition::Is_Mounted(void) {
1101 if (!Can_Be_Mounted)
1102 return false;
1103
1104 struct stat st1, st2;
1105 string test_path;
1106
1107 // Check to see if the mount point directory exists
1108 test_path = Mount_Point + "/.";
1109 if (stat(test_path.c_str(), &st1) != 0) return false;
1110
1111 // Check to see if the directory above the mount point exists
1112 test_path = Mount_Point + "/../.";
1113 if (stat(test_path.c_str(), &st2) != 0) return false;
1114
1115 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
1116 int ret = (st1.st_dev != st2.st_dev) ? true : false;
1117
1118 return ret;
1119}
1120
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001121bool TWPartition::Is_File_System_Writable(void) {
1122 if (!Is_File_System(Current_File_System) || !Is_Mounted())
1123 return false;
1124
1125 string test_path = Mount_Point + "/.";
1126 return (access(test_path.c_str(), W_OK) == 0);
1127}
1128
Dees_Troy5bf43922012-09-07 16:07:55 -04001129bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001130 int exfat_mounted = 0;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001131 unsigned long flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001132
Dees_Troy5bf43922012-09-07 16:07:55 -04001133 if (Is_Mounted()) {
1134 return true;
1135 } else if (!Can_Be_Mounted) {
1136 return false;
1137 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001138
1139 Find_Actual_Block_Device();
1140
1141 // Check the current file system before mounting
1142 Check_FS_Type();
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001143 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
Dees_Troye34c1332013-02-06 19:13:00 +00001144 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 +00001145 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001146 string result;
1147 if (TWFunc::Exec_Cmd(cmd, result) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001148 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001149 Current_File_System = "vfat";
1150 } else {
1151#ifdef TW_NO_EXFAT_FUSE
1152 UnMount(false);
1153 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1154 // Some kernels let us mount vfat as exfat which doesn't work out too well
1155#else
1156 exfat_mounted = 1;
1157#endif
1158 }
1159 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001160
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001161 if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfs-3g") || TWFunc::Path_Exists("/sbin/mount.ntfs"))) {
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001162 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001163 string Ntfsmount_Binary = "";
1164
1165 if (TWFunc::Path_Exists("/sbin/ntfs-3g"))
1166 Ntfsmount_Binary = "ntfs-3g";
1167 else if (TWFunc::Path_Exists("/sbin/mount.ntfs"))
1168 Ntfsmount_Binary = "mount.ntfs";
1169
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001170 if (Mount_Read_Only)
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001171 cmd = "/sbin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001172 else
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001173 cmd = "/sbin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001174 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001175
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001176 if (TWFunc::Exec_Cmd(cmd) == 0) {
1177 return true;
1178 } else {
1179 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1180 }
1181 }
1182
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001183 if (Mount_Read_Only)
1184 flags |= MS_RDONLY;
1185
Dees_Troy22042032012-12-18 21:23:08 +00001186 if (Fstab_File_System == "yaffs2") {
1187 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001188 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1189 if (Mount_Read_Only)
1190 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001191 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1192 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1193 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001194 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001195 else
1196 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1197 return false;
1198 } else {
1199 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1200 return true;
1201 }
1202 } else {
1203 struct stat st;
1204 string test_path = Mount_Point;
1205 if (stat(test_path.c_str(), &st) < 0) {
1206 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001207 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001208 else
1209 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1210 return false;
1211 }
1212 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1213 if (new_mode != st.st_mode) {
1214 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1215 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1216 if (Display_Error)
1217 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1218 else
1219 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1220 return false;
1221 }
1222 }
Dees_Troy22042032012-12-18 21:23:08 +00001223 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001224 }
thatc7572eb2015-03-31 18:55:30 +02001225 }
1226
1227 string mount_fs = Current_File_System;
1228 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1229 mount_fs = "texfat";
1230
1231 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001232 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1233 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001234#ifdef TW_NO_EXFAT_FUSE
1235 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001236 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001237 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001238 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001239 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001240 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001241 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001242 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 +00001243 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001244 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001245 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001246#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001247 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001248 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001249 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001250 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1251 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 +00001252 return false;
1253#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001254 }
1255#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001256 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001257
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001258 if (Removable)
1259 Update_Size(Display_Error);
1260
xiaolu9416f4f2015-06-04 08:22:23 +08001261 if (!Symlink_Mount_Point.empty() && TWFunc::Path_Exists(Symlink_Path)) {
codelover2a3d4ce2015-03-14 20:26:49 +08001262 string Command = "mount -o bind '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
Vojtech Bocek05534202013-09-11 08:11:56 +02001263 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001264 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001265 return true;
1266}
1267
1268bool TWPartition::UnMount(bool Display_Error) {
1269 if (Is_Mounted()) {
1270 int never_unmount_system;
1271
1272 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
1273 if (never_unmount_system == 1 && Mount_Point == "/system")
1274 return true; // Never unmount system if you're not supposed to unmount it
1275
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001276 if (Is_Storage)
Ethan Yonker726a0202014-12-16 20:01:38 -06001277 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001278
Dees_Troy38bd7602012-09-14 13:33:53 -04001279 if (!Symlink_Mount_Point.empty())
1280 umount(Symlink_Mount_Point.c_str());
1281
Dees_Troyb05ddee2013-01-28 20:24:50 +00001282 umount(Mount_Point.c_str());
1283 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001284 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001285 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001286 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001287 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001288 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001289 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001290 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001291 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001292 } else {
1293 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001294 }
1295}
1296
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05001297bool TWPartition::ReMount(bool Display_Error) {
1298 if (UnMount(Display_Error))
1299 return Mount(Display_Error);
1300 return false;
1301}
1302
1303bool TWPartition::ReMount_RW(bool Display_Error) {
1304 // No need to remount if already mounted rw
1305 if (Is_File_System_Writable())
1306 return true;
1307
1308 bool ro = Mount_Read_Only;
1309 int flags = Mount_Flags;
1310
1311 Mount_Read_Only = false;
1312 Mount_Flags &= ~MS_RDONLY;
1313
1314 bool ret = ReMount(Display_Error);
1315
1316 Mount_Read_Only = ro;
1317 Mount_Flags = flags;
1318
1319 return ret;
1320}
1321
Gary Peck43acadf2012-11-21 21:19:01 -08001322bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001323 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001324 int check;
1325 string Layout_Filename = Mount_Point + "/.layout_version";
1326
Dees_Troy38bd7602012-09-14 13:33:53 -04001327 if (!Can_Be_Wiped) {
Matt Mower3c366972015-12-25 19:28:31 -06001328 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001329 return false;
1330 }
1331
Dees_Troyc51f1f92012-09-20 15:32:13 -04001332 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001333 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001334
Dees_Troy16c2b312013-01-15 16:51:18 +00001335 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
1336 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
1337 else
1338 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -04001339
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001340 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001341 wiped = Wipe_Data_Without_Wiping_Media();
Ethan Yonker5eac2222014-06-11 12:22:55 -05001342 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001343 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001344 DataManager::GetValue(TW_RM_RF_VAR, check);
1345
Hashcodedabfd492013-08-29 22:45:30 -07001346 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001347 wiped = Wipe_RMRF();
1348 else if (New_File_System == "ext4")
1349 wiped = Wipe_EXT4();
1350 else if (New_File_System == "ext2" || New_File_System == "ext3")
1351 wiped = Wipe_EXT23(New_File_System);
1352 else if (New_File_System == "vfat")
1353 wiped = Wipe_FAT();
1354 else if (New_File_System == "exfat")
1355 wiped = Wipe_EXFAT();
1356 else if (New_File_System == "yaffs2")
1357 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001358 else if (New_File_System == "f2fs")
1359 wiped = Wipe_F2FS();
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001360 else if (New_File_System == "ntfs")
1361 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001362 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001363 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 +00001364 unlink("/.layout_version");
1365 return false;
1366 }
1367 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001368 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001369
Gary Pecke8bc5d72012-12-21 06:45:25 -08001370 if (wiped) {
Dees_Troy1c1ac442013-01-17 21:42:14 +00001371 if (Mount_Point == "/cache")
1372 DataManager::Output_Version();
1373
Dees_Troy16c2b312013-01-15 16:51:18 +00001374 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
1375 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
1376
1377 if (update_crypt) {
1378 Setup_File_System(false);
1379 if (Is_Encrypted && !Is_Decrypted) {
1380 // just wiped an encrypted partition back to its unencrypted state
1381 Is_Encrypted = false;
1382 Is_Decrypted = false;
1383 Decrypted_Block_Device = "";
1384 if (Mount_Point == "/data") {
1385 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1386 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1387 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001388 }
1389 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001390
Ethan Yonker66a19492015-12-10 10:19:45 -06001391 if (Has_Data_Media && recreate_media) {
Ethan Yonker5eac2222014-06-11 12:22:55 -05001392 Recreate_Media_Folder();
1393 }
Matt Mower209c9632016-01-20 12:08:35 -06001394 if (Is_Storage && Mount(false))
1395 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Gary Pecke8bc5d72012-12-21 06:45:25 -08001396 }
Matt Mower209c9632016-01-20 12:08:35 -06001397
Gary Pecke8bc5d72012-12-21 06:45:25 -08001398 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001399}
1400
Gary Peck43acadf2012-11-21 21:19:01 -08001401bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001402 if (Is_File_System(Current_File_System))
1403 return Wipe(Current_File_System);
1404 else
1405 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001406}
1407
Dees_Troye58d5262012-09-21 12:27:57 -04001408bool TWPartition::Wipe_AndSec(void) {
1409 if (!Has_Android_Secure)
1410 return false;
1411
Dees_Troye58d5262012-09-21 12:27:57 -04001412 if (!Mount(true))
1413 return false;
1414
Ethan Yonker74db1572015-10-28 12:44:49 -05001415 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001416 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001417 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001418}
1419
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001420bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001421 if (Mount_Read_Only)
1422 return false;
Matt Mower18794c82015-11-11 16:22:45 -06001423 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/sbin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001424 return true;
1425 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/e2fsck"))
1426 return true;
1427 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/fsck.exfat"))
1428 return true;
1429 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/sbin/fsck.f2fs"))
1430 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001431 else if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfsfix") || TWFunc::Path_Exists("/sbin/fsck.ntfs")))
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001432 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001433 return false;
1434}
1435
1436bool TWPartition::Repair() {
1437 string command;
1438
1439 if (Current_File_System == "vfat") {
Matt Mower18794c82015-11-11 16:22:45 -06001440 if (!TWFunc::Path_Exists("/sbin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001441 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001442 return false;
1443 }
1444 if (!UnMount(true))
1445 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001446 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001447 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06001448 command = "/sbin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001449 LOGINFO("Repair command: %s\n", command.c_str());
1450 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001451 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001452 return true;
1453 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001454 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001455 return false;
1456 }
1457 }
1458 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1459 if (!TWFunc::Path_Exists("/sbin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001460 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001461 return false;
1462 }
1463 if (!UnMount(true))
1464 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001465 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001466 Find_Actual_Block_Device();
Ethan Yonkera2719152015-05-28 09:44:41 -05001467 command = "/sbin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001468 LOGINFO("Repair command: %s\n", command.c_str());
1469 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001470 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001471 return true;
1472 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001473 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001474 return false;
1475 }
1476 }
1477 if (Current_File_System == "exfat") {
1478 if (!TWFunc::Path_Exists("/sbin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001479 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001480 return false;
1481 }
1482 if (!UnMount(true))
1483 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001484 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001485 Find_Actual_Block_Device();
1486 command = "/sbin/fsck.exfat " + Actual_Block_Device;
1487 LOGINFO("Repair command: %s\n", command.c_str());
1488 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001489 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001490 return true;
1491 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001492 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001493 return false;
1494 }
1495 }
1496 if (Current_File_System == "f2fs") {
1497 if (!TWFunc::Path_Exists("/sbin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001498 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001499 return false;
1500 }
1501 if (!UnMount(true))
1502 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001503 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001504 Find_Actual_Block_Device();
1505 command = "/sbin/fsck.f2fs " + Actual_Block_Device;
1506 LOGINFO("Repair command: %s\n", command.c_str());
1507 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001508 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001509 return true;
1510 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001511 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001512 return false;
1513 }
1514 }
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001515 if (Current_File_System == "ntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001516 string Ntfsfix_Binary;
1517 if (TWFunc::Path_Exists("/sbin/ntfsfix"))
1518 Ntfsfix_Binary = "ntfsfix";
1519 else if (TWFunc::Path_Exists("/sbin/fsck.ntfs"))
1520 Ntfsfix_Binary = "fsck.ntfs";
1521 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001522 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001523 return false;
1524 }
1525 if (!UnMount(true))
1526 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001527 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001528 Find_Actual_Block_Device();
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001529 command = "/sbin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001530 LOGINFO("Repair command: %s\n", command.c_str());
1531 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001532 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001533 return true;
1534 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001535 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001536 return false;
1537 }
1538 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001539 return false;
1540}
1541
Ethan Yonkera2719152015-05-28 09:44:41 -05001542bool TWPartition::Can_Resize() {
1543 if (Mount_Read_Only)
1544 return false;
1545 if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/resize2fs"))
1546 return true;
1547 return false;
1548}
1549
1550bool TWPartition::Resize() {
1551 string command;
1552
1553 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1554 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001555 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1556 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001557 return false;
1558 }
1559 if (!TWFunc::Path_Exists("/sbin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001560 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1561 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001562 return false;
1563 }
1564 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001565 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001566 if (!Repair())
1567 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001568 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001569 Find_Actual_Block_Device();
1570 command = "/sbin/resize2fs " + Actual_Block_Device;
1571 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001572 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1573 if (Actual_Size == 0)
1574 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001575
Ethan Yonkera2719152015-05-28 09:44:41 -05001576 unsigned long long Block_Count;
1577 if (Length < 0) {
1578 // Reduce overall size by this length
1579 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1580 } else {
1581 // This is the size, not a size reduction
1582 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1583 }
1584 char temp[256];
1585 sprintf(temp, "%llu", Block_Count);
1586 command += " ";
1587 command += temp;
1588 command += "K";
1589 }
1590 LOGINFO("Resize command: %s\n", command.c_str());
1591 if (TWFunc::Exec_Cmd(command) == 0) {
1592 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001593 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001594 return true;
1595 } else {
1596 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001597 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001598 return false;
1599 }
1600 }
1601 return false;
1602}
1603
bigbiffce8f83c2015-12-12 18:30:21 -05001604bool TWPartition::Backup(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
1605 if (Backup_Method == BM_FILES)
1606 return Backup_Tar(part_settings, tar_fork_pid);
1607 else if (Backup_Method == BM_DD)
1608 return Backup_Image(part_settings);
1609 else if (Backup_Method == BM_FLASH_UTILS)
1610 return Backup_Dump_Image(part_settings);
Dees_Troy2673cec2013-04-02 20:22:16 +00001611 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001612 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001613}
1614
Dees_Troy43d8b002012-09-17 16:00:01 -04001615bool TWPartition::Check_MD5(string restore_folder) {
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001616 string Full_Filename, md5file;
Dees_Troy43d8b002012-09-17 16:00:01 -04001617 char split_filename[512];
1618 int index = 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001619 twrpDigest md5sum;
Dees_Troy43d8b002012-09-17 16:00:01 -04001620
Captain Throwbackff5935f2014-09-23 16:08:34 -04001621 sync();
1622
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001623 memset(split_filename, 0, sizeof(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001624 Full_Filename = restore_folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04001625 if (!TWFunc::Path_Exists(Full_Filename)) {
1626 // This is a split archive, we presume
1627 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
Dees_Troy2673cec2013-04-02 20:22:16 +00001628 LOGINFO("split_filename: %s\n", split_filename);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001629 md5file = split_filename;
1630 md5file += ".md5";
1631 if (!TWFunc::Path_Exists(md5file)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001632 gui_msg(Msg(msg::kError, "no_md5_found=No md5 file found for '{1}'. Please unselect Enable MD5 verification to restore.")(split_filename));
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001633 return false;
1634 }
1635 md5sum.setfn(split_filename);
Dees_Troy83bd4832013-05-04 12:39:56 +00001636 while (index < 1000) {
1637 if (TWFunc::Path_Exists(split_filename) && md5sum.verify_md5digest() != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001638 gui_msg(Msg(msg::kError, "md5_fail_match=MD5 failed to match on '{1}'.")(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001639 return false;
1640 }
1641 index++;
1642 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001643 md5sum.setfn(split_filename);
Dees_Troy43d8b002012-09-17 16:00:01 -04001644 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001645 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001646 } else {
1647 // Single file archive
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001648 md5file = Full_Filename + ".md5";
1649 if (!TWFunc::Path_Exists(md5file)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001650 gui_msg(Msg(msg::kError, "no_md5_found=No md5 file found for '{1}'. Please unselect Enable MD5 verification to restore.")(split_filename));
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001651 return false;
1652 }
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001653 md5sum.setfn(Full_Filename);
1654 if (md5sum.verify_md5digest() != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001655 gui_msg(Msg(msg::kError, "md5_fail_match=MD5 failed to match on '{1}'.")(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001656 return false;
1657 } else
1658 return true;
1659 }
1660 return false;
1661}
1662
bigbiffce8f83c2015-12-12 18:30:21 -05001663bool TWPartition::Restore(PartitionSettings *part_settings) {
Matt Mower3c366972015-12-25 19:28:31 -06001664 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring_hdr}"));
bigbiffce8f83c2015-12-12 18:30:21 -05001665 LOGINFO("Restore filename is: %s/%s\n", part_settings->Restore_Name.c_str(), part_settings->Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001666
bigbiffce8f83c2015-12-12 18:30:21 -05001667 string Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001668
1669 if (Is_File_System(Restore_File_System))
bigbiffce8f83c2015-12-12 18:30:21 -05001670 return Restore_Tar(part_settings);
1671 else if (Is_Image(Restore_File_System))
1672 return Restore_Image(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001673
1674 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1675 return false;
1676}
1677
bigbiffce8f83c2015-12-12 18:30:21 -05001678string TWPartition::Get_Restore_File_System(PartitionSettings *part_settings) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001679 size_t first_period, second_period;
1680 string Restore_File_System;
1681
Gary Peck43acadf2012-11-21 21:19:01 -08001682 // Parse backup filename to extract the file system before wiping
bigbiffce8f83c2015-12-12 18:30:21 -05001683 first_period = part_settings->Backup_FileName.find(".");
Gary Peck43acadf2012-11-21 21:19:01 -08001684 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001685 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001686 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001687 }
bigbiffce8f83c2015-12-12 18:30:21 -05001688 Restore_File_System = part_settings->Backup_FileName.substr(first_period + 1, part_settings->Backup_FileName.size() - first_period - 1);
Gary Peck43acadf2012-11-21 21:19:01 -08001689 second_period = Restore_File_System.find(".");
1690 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001691 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001692 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001693 }
1694 Restore_File_System.resize(second_period);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001695 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04001696}
1697
1698string TWPartition::Backup_Method_By_Name() {
bigbiffce8f83c2015-12-12 18:30:21 -05001699 if (Backup_Method == BM_NONE)
Dees_Troy38bd7602012-09-14 13:33:53 -04001700 return "none";
bigbiffce8f83c2015-12-12 18:30:21 -05001701 else if (Backup_Method == BM_FILES)
Dees_Troy38bd7602012-09-14 13:33:53 -04001702 return "files";
bigbiffce8f83c2015-12-12 18:30:21 -05001703 else if (Backup_Method == BM_DD)
Dees_Troy38bd7602012-09-14 13:33:53 -04001704 return "dd";
bigbiffce8f83c2015-12-12 18:30:21 -05001705 else if (Backup_Method == BM_FLASH_UTILS)
Dees_Troy38bd7602012-09-14 13:33:53 -04001706 return "flash_utils";
1707 else
1708 return "undefined";
1709 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04001710}
1711
1712bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001713 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001714 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04001715 return 1;
1716}
1717
1718bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001719 bool Save_Data_Media = Has_Data_Media;
1720
1721 if (!UnMount(true))
1722 return false;
1723
Dees_Troy38bd7602012-09-14 13:33:53 -04001724 Has_Data_Media = false;
Dees_Troy74fb2e92013-04-15 14:35:47 +00001725 Decrypted_Block_Device = "";
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001726#ifdef TW_INCLUDE_CRYPTO
1727 if (Is_Decrypted) {
1728 if (!UnMount(true))
1729 return false;
Matt Mower2b18a532015-02-20 16:58:05 -06001730 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001731 LOGERR("Error deleting crypto block device, continuing anyway.\n");
1732 }
1733 }
1734#endif
Dees_Troy74fb2e92013-04-15 14:35:47 +00001735 Is_Decrypted = false;
1736 Is_Encrypted = false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001737 Find_Actual_Block_Device();
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001738 if (Crypto_Key_Location == "footer") {
1739 int newlen, fd;
1740 if (Length != 0) {
1741 newlen = Length;
1742 if (newlen < 0)
1743 newlen = newlen * -1;
1744 } else {
1745 newlen = CRYPT_FOOTER_OFFSET;
1746 }
1747 if ((fd = open(Actual_Block_Device.c_str(), O_RDWR)) < 0) {
1748 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
1749 } else {
1750 unsigned int block_count;
1751 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
1752 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
1753 } else {
1754 off64_t offset = ((off64_t)block_count * 512) - newlen;
1755 if (lseek64(fd, offset, SEEK_SET) == -1) {
1756 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
1757 } else {
1758 void* buffer = malloc(newlen);
1759 if (!buffer) {
1760 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
1761 } else {
1762 memset(buffer, 0, newlen);
1763 int ret = write(fd, buffer, newlen);
1764 if (ret != newlen) {
1765 gui_print_color("warning", "Failed to wipe crypto footer.\n");
1766 } else {
1767 LOGINFO("Successfully wiped crypto footer.\n");
1768 }
Matt Mower13a8f0b2015-09-26 15:40:03 -05001769 free(buffer);
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001770 }
1771 }
1772 }
1773 close(fd);
1774 }
1775 } else {
Ethan Yonkerc2dafbb2016-03-15 22:20:59 -05001776 if (TWFunc::IOCTL_Get_Block_Size(Crypto_Key_Location.c_str()) >= 16384LLU) {
1777 string Command = "dd of='" + Crypto_Key_Location + "' if=/dev/zero bs=16384 count=1";
1778 TWFunc::Exec_Cmd(Command);
1779 } else {
1780 LOGINFO("Crypto key location reports size < 16K so not wiping crypto footer.\n");
1781 }
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001782 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001783 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001784 Has_Data_Media = Save_Data_Media;
1785 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
1786 Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001787 if (Mount(false))
1788 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001789 }
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001790 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05001791#ifndef TW_OEM_BUILD
Ethan Yonker74db1572015-10-28 12:44:49 -05001792 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 -05001793#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001794 return true;
1795 } else {
1796 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05001797 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06001798 if (Has_Data_Media && Mount(false))
1799 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001800 return false;
1801 }
1802 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001803}
1804
1805void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001806 const char* type;
1807 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04001808
Dees_Troy68cab492012-12-12 19:29:35 +00001809 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1810 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001811
Dees_Troy38bd7602012-09-14 13:33:53 -04001812 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001813 if (!Is_Present)
1814 return;
Dees_Troy51127312012-09-08 13:08:49 -04001815
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001816 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
1817 if (blkid_do_fullprobe(pr)) {
1818 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001819 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001820 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001821 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001822
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001823 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001824 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001825 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001826 return;
1827 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001828
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001829 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001830 blkid_free_probe(pr);
Dees_Troy51a0e822012-09-05 15:24:24 -04001831}
1832
Gary Peck43acadf2012-11-21 21:19:01 -08001833bool TWPartition::Wipe_EXT23(string File_System) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001834 if (!UnMount(true))
1835 return false;
1836
Dees_Troy43d8b002012-09-17 16:00:01 -04001837 if (TWFunc::Path_Exists("/sbin/mke2fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001838 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001839
Greg Wallace4b44fef2015-12-29 15:33:24 -05001840 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001841 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001842 command = "mke2fs -t " + File_System + " -m 0 " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001843 LOGINFO("mke2fs command: %s\n", command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001844 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001845 Current_File_System = File_System;
Dees_Troye58d5262012-09-21 12:27:57 -04001846 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001847 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04001848 return true;
1849 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001850 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001851 return false;
1852 }
1853 } else
1854 return Wipe_RMRF();
1855
1856 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001857}
1858
1859bool TWPartition::Wipe_EXT4() {
Ethan Yonker25f20c12014-10-14 09:04:43 -05001860 Find_Actual_Block_Device();
1861 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001862 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
1863 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05001864 return false;
1865 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001866 if (!UnMount(true))
1867 return false;
1868
Dees_Troyb3265ab2013-08-30 02:59:14 +00001869#if defined(HAVE_SELINUX) && defined(USE_EXT4)
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001870 int ret;
1871 char *secontext = NULL;
1872
Greg Wallace4b44fef2015-12-29 15:33:24 -05001873 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001874
Dees Troy99c8dbf2014-03-10 16:53:58 +00001875 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001876 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
1877 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), NULL);
1878 } else {
1879 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), selinux_handle);
1880 }
1881 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001882 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00001883 return false;
1884 } else {
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04001885 string sedir = Mount_Point + "/lost+found";
1886 PartitionManager.Mount_By_Path(sedir.c_str(), true);
1887 rmdir(sedir.c_str());
1888 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00001889 return true;
1890 }
1891#else
Dees_Troy43d8b002012-09-17 16:00:01 -04001892 if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001893 string Command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001894
Greg Wallace4b44fef2015-12-29 15:33:24 -05001895 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001896 Find_Actual_Block_Device();
1897 Command = "make_ext4fs";
1898 if (!Is_Decrypted && Length != 0) {
1899 // Only use length if we're not decrypted
1900 char len[32];
1901 sprintf(len, "%i", Length);
1902 Command += " -l ";
1903 Command += len;
1904 }
Dees_Troy5295d582013-09-06 15:51:08 +00001905 if (TWFunc::Path_Exists("/file_contexts")) {
1906 Command += " -S /file_contexts";
1907 }
1908 Command += " -a " + Mount_Point + " " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001909 LOGINFO("make_ext4fs command: %s\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001910 if (TWFunc::Exec_Cmd(Command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001911 Current_File_System = "ext4";
Dees_Troye58d5262012-09-21 12:27:57 -04001912 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001913 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04001914 return true;
1915 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001916 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001917 return false;
1918 }
1919 } else
Gary Peck43acadf2012-11-21 21:19:01 -08001920 return Wipe_EXT23("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00001921#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001922 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001923}
1924
1925bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001926 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001927
Matt Mower18794c82015-11-11 16:22:45 -06001928 if (TWFunc::Path_Exists("/sbin/mkfs.fat")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001929 if (!UnMount(true))
1930 return false;
1931
Greg Wallace4b44fef2015-12-29 15:33:24 -05001932 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001933 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06001934 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001935 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001936 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04001937 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001938 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04001939 return true;
1940 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001941 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001942 return false;
1943 }
1944 return true;
1945 }
1946 else
1947 return Wipe_RMRF();
1948
1949 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001950}
1951
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001952bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001953 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001954
1955 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
1956 if (!UnMount(true))
1957 return false;
1958
Greg Wallace4b44fef2015-12-29 15:33:24 -05001959 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001960 Find_Actual_Block_Device();
1961 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001962 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001963 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001964 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001965 return true;
1966 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001967 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001968 return false;
1969 }
1970 return true;
1971 }
1972 return false;
1973}
1974
Dees_Troy38bd7602012-09-14 13:33:53 -04001975bool TWPartition::Wipe_MTD() {
1976 if (!UnMount(true))
1977 return false;
1978
Greg Wallace4b44fef2015-12-29 15:33:24 -05001979 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001980
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001981 mtd_scan_partitions();
1982 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
1983 if (mtd == NULL) {
1984 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
1985 return false;
1986 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001987
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001988 MtdWriteContext* ctx = mtd_write_partition(mtd);
1989 if (ctx == NULL) {
1990 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
1991 return false;
1992 }
1993 if (mtd_erase_blocks(ctx, -1) == -1) {
1994 mtd_write_close(ctx);
1995 LOGERR("Failed to format '%s'", MTD_Name.c_str());
1996 return false;
1997 }
1998 if (mtd_write_close(ctx) != 0) {
1999 LOGERR("Failed to close '%s'", MTD_Name.c_str());
2000 return false;
2001 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08002002 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04002003 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002004 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002005 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002006}
2007
2008bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04002009 if (!Mount(true))
2010 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002011 // This is the only wipe that leaves the partition mounted, so we
2012 // must manually remove the partition from MTP if it is a storage
2013 // partition.
2014 if (Is_Storage)
2015 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04002016
Ethan Yonker74db1572015-10-28 12:44:49 -05002017 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002018 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002019 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002020 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002021}
2022
Dees_Troye5017042013-08-29 16:38:55 +00002023bool TWPartition::Wipe_F2FS() {
Vojtech Bocek05534202013-09-11 08:11:56 +02002024 string command;
Dees_Troye5017042013-08-29 16:38:55 +00002025
2026 if (TWFunc::Path_Exists("/sbin/mkfs.f2fs")) {
2027 if (!UnMount(true))
2028 return false;
2029
Greg Wallace4b44fef2015-12-29 15:33:24 -05002030 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.f2fs"));
Dees_Troye5017042013-08-29 16:38:55 +00002031 Find_Actual_Block_Device();
Greg Wallace558aef72016-01-19 21:14:30 -05002032 command = "mkfs.f2fs -t 0";
dhacker29a3fa75f2015-01-17 19:42:33 -05002033 if (!Is_Decrypted && Length != 0) {
2034 // Only use length if we're not decrypted
2035 char len[32];
2036 int mod_length = Length;
2037 if (Length < 0)
2038 mod_length *= -1;
2039 sprintf(len, "%i", mod_length);
2040 command += " -r ";
2041 command += len;
2042 }
2043 command += " " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02002044 if (TWFunc::Exec_Cmd(command) == 0) {
Dees_Troye5017042013-08-29 16:38:55 +00002045 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05002046 gui_msg("done=Done.");
Dees_Troye5017042013-08-29 16:38:55 +00002047 return true;
2048 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002049 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troye5017042013-08-29 16:38:55 +00002050 return false;
2051 }
2052 return true;
2053 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002054 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00002055 return Wipe_RMRF();
2056 }
2057 return false;
2058}
2059
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002060bool TWPartition::Wipe_NTFS() {
2061 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002062 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002063
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002064 if (TWFunc::Path_Exists("/sbin/mkntfs"))
2065 Ntfsmake_Binary = "mkntfs";
2066 else if (TWFunc::Path_Exists("/sbin/mkfs.ntfs"))
2067 Ntfsmake_Binary = "mkfs.ntfs";
2068 else
2069 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002070
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002071 if (!UnMount(true))
2072 return false;
2073
Greg Wallace4b44fef2015-12-29 15:33:24 -05002074 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002075 Find_Actual_Block_Device();
2076 command = "/sbin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
2077 if (TWFunc::Exec_Cmd(command) == 0) {
2078 Recreate_AndSec_Folder();
2079 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002080 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05002081 } else {
2082 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
2083 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05002084 }
2085 return false;
2086}
2087
Dees_Troy51a0e822012-09-05 15:24:24 -04002088bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05002089#ifdef TW_OEM_BUILD
2090 // In an OEM Build we want to do a full format
2091 return Wipe_Encryption();
2092#else
Ethan Yonker66a19492015-12-10 10:19:45 -06002093 bool ret = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04002094
Dees_Troy38bd7602012-09-14 13:33:53 -04002095 if (!Mount(true))
2096 return false;
2097
Ethan Yonker74db1572015-10-28 12:44:49 -05002098 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Ethan Yonker66a19492015-12-10 10:19:45 -06002099 ret = Wipe_Data_Without_Wiping_Media_Func(Mount_Point + "/");
2100 if (ret)
2101 gui_msg("done=Done.");
2102 return ret;
2103#endif // ifdef TW_OEM_BUILD
2104}
2105
2106bool TWPartition::Wipe_Data_Without_Wiping_Media_Func(const string& parent __unused) {
2107 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04002108
2109 DIR* d;
Ethan Yonker66a19492015-12-10 10:19:45 -06002110 d = opendir(parent.c_str());
Dees_Troy16b74352012-11-14 22:27:31 +00002111 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002112 struct dirent* de;
2113 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002114 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002115
Ethan Yonker66a19492015-12-10 10:19:45 -06002116 dir = parent;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002117 dir.append(de->d_name);
Ethan Yonker66a19492015-12-10 10:19:45 -06002118 if (du.check_skip_dirs(dir)) {
2119 LOGINFO("skipped '%s'\n", dir.c_str());
2120 continue;
2121 }
Dees_Troyce675462013-01-09 19:48:21 +00002122 if (de->d_type == DT_DIR) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002123 dir.append("/");
2124 if (!Wipe_Data_Without_Wiping_Media_Func(dir)) {
2125 closedir(d);
2126 return false;
2127 }
2128 rmdir(dir.c_str());
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05002129 } else if (de->d_type == DT_REG || de->d_type == DT_LNK || de->d_type == DT_FIFO || de->d_type == DT_SOCK) {
Dees_Troyce675462013-01-09 19:48:21 +00002130 if (!unlink(dir.c_str()))
Dees_Troy2673cec2013-04-02 20:22:16 +00002131 LOGINFO("Unable to unlink '%s'\n", dir.c_str());
Dees_Troyce675462013-01-09 19:48:21 +00002132 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002133 }
2134 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05002135
Dees_Troy16b74352012-11-14 22:27:31 +00002136 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04002137 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002138 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00002139 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04002140}
2141
bigbiffce8f83c2015-12-12 18:30:21 -05002142bool TWPartition::Backup_Tar(PartitionSettings *part_settings, pid_t *tar_fork_pid) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002143 string Full_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002144 twrpTar tar;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05002145
Dees_Troy43d8b002012-09-17 16:00:01 -04002146 if (!Mount(true))
2147 return false;
2148
Dees_Troya13d74f2013-03-24 08:54:55 -05002149 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, "Backing Up");
Ethan Yonker74db1572015-10-28 12:44:49 -05002150 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002151
Ethan Yonker472f5062016-02-25 13:47:30 -06002152 DataManager::GetValue(TW_USE_COMPRESSION_VAR, tar.use_compression);
Matt Mowerbb81e5d2014-03-20 18:05:41 -05002153
Dees_Troy83bd4832013-05-04 12:39:56 +00002154#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
Ethan Yonker472f5062016-02-25 13:47:30 -06002155 if (Can_Encrypt_Backup) {
2156 DataManager::GetValue("tw_encrypt_backup", tar.use_encryption);
2157 if (tar.use_encryption) {
2158 if (Use_Userdata_Encryption)
2159 tar.userdata_encryption = tar.use_encryption;
2160 string Password;
2161 DataManager::GetValue("tw_backup_password", Password);
2162 tar.setpassword(Password);
2163 } else {
2164 tar.use_encryption = 0;
2165 }
Dees_Troy83bd4832013-05-04 12:39:56 +00002166 }
2167#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04002168
Ethan Yonker472f5062016-02-25 13:47:30 -06002169 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
bigbiffce8f83c2015-12-12 18:30:21 -05002170 Full_FileName = part_settings->Full_Backup_Path + Backup_FileName;
Dees_Troy83bd4832013-05-04 12:39:56 +00002171 tar.has_data_media = Has_Data_Media;
bigbiffce8f83c2015-12-12 18:30:21 -05002172 tar.part_settings = part_settings;
Dees Troye0a433a2013-12-02 04:10:37 +00002173 tar.setdir(Backup_Path);
2174 tar.setfn(Full_FileName);
2175 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002176 tar.partition_name = Backup_Name;
bigbiffce8f83c2015-12-12 18:30:21 -05002177 tar.backup_folder = part_settings->Full_Backup_Path;
2178 if (tar.createTarFork(tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002179 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002180 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002181}
2182
bigbiffce8f83c2015-12-12 18:30:21 -05002183bool TWPartition::Backup_Image(PartitionSettings *part_settings) {
2184 string Full_FileName, adb_file_name;
2185 int adb_control_bu_fd, compressed;
igoriok87e3d932013-01-31 21:03:53 +02002186
Ethan Yonker74db1572015-10-28 12:44:49 -05002187 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2188 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002189
Ethan Yonker472f5062016-02-25 13:47:30 -06002190 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
Dees_Troy43d8b002012-09-17 16:00:01 -04002191
bigbiffce8f83c2015-12-12 18:30:21 -05002192 if (part_settings->adbbackup) {
2193 Full_FileName = TW_ADB_BACKUP;
2194 adb_file_name = part_settings->Full_Backup_Path + "/" + Backup_FileName;
2195 }
2196 else
2197 Full_FileName = part_settings->Full_Backup_Path + "/" + Backup_FileName;
2198
2199 part_settings->total_restore_size = Backup_Size;
2200
2201 if (part_settings->adbbackup) {
2202 if (!twadbbu::Write_TWIMG(adb_file_name, Backup_Size))
2203 return false;
2204 }
2205
2206 if (!Raw_Read_Write(part_settings))
Ethan Yonker472f5062016-02-25 13:47:30 -06002207 return false;
2208
bigbiffce8f83c2015-12-12 18:30:21 -05002209 if (part_settings->adbbackup) {
2210 if (!twadbbu::Write_TWEOF())
2211 return false;
Dees_Troy7c2dec82012-09-26 09:49:14 -04002212 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002213 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002214}
2215
bigbiffce8f83c2015-12-12 18:30:21 -05002216bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) {
2217 unsigned long long RW_Block_Size, Remain = Backup_Size;
2218 int src_fd = -1, dest_fd = -1;
2219 ssize_t bs;
Ethan Yonker472f5062016-02-25 13:47:30 -06002220 bool ret = false;
2221 void* buffer = NULL;
2222 unsigned long long backedup_size = 0;
bigbiffce8f83c2015-12-12 18:30:21 -05002223 string srcfn, destfn;
Ethan Yonker472f5062016-02-25 13:47:30 -06002224
bigbiffce8f83c2015-12-12 18:30:21 -05002225 if (part_settings->PM_Method == PM_BACKUP) {
2226 srcfn = Actual_Block_Device;
2227 if (part_settings->adbbackup)
2228 destfn = TW_ADB_BACKUP;
2229 else
2230 destfn = part_settings->Full_Backup_Path + part_settings->Backup_FileName;
2231 }
2232 else {
2233 destfn = Actual_Block_Device;
2234 if (part_settings->adbbackup) {
2235 srcfn = TW_ADB_RESTORE;
2236 } else {
2237 srcfn = part_settings->Restore_Name + "/" + part_settings->Backup_FileName;
2238 Remain = TWFunc::Get_File_Size(srcfn);
2239 }
2240 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002241
bigbiffce8f83c2015-12-12 18:30:21 -05002242 src_fd = open(srcfn.c_str(), O_RDONLY | O_LARGEFILE);
Ethan Yonker472f5062016-02-25 13:47:30 -06002243 if (src_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002244 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(srcfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002245 return false;
2246 }
bigbiffce8f83c2015-12-12 18:30:21 -05002247
2248 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 -06002249 if (dest_fd < 0) {
bigbiffce8f83c2015-12-12 18:30:21 -05002250 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno)));
Ethan Yonker472f5062016-02-25 13:47:30 -06002251 goto exit;
2252 }
bigbiffce8f83c2015-12-12 18:30:21 -05002253
2254 LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str());
2255
2256 if (part_settings->adbbackup) {
2257 RW_Block_Size = MAX_ADB_READ;
2258 bs = MAX_ADB_READ;
2259 }
2260 else {
2261 RW_Block_Size = 1048576LLU; // 1MB
2262 bs = (ssize_t)(RW_Block_Size);
2263 }
2264
Ethan Yonker472f5062016-02-25 13:47:30 -06002265 buffer = malloc((size_t)bs);
2266 if (!buffer) {
2267 LOGINFO("Raw_Read_Write failed to malloc\n");
2268 goto exit;
2269 }
bigbiffce8f83c2015-12-12 18:30:21 -05002270
2271 if (part_settings->progress)
2272 part_settings->progress->SetPartitionSize(part_settings->total_restore_size);
2273
Ethan Yonker472f5062016-02-25 13:47:30 -06002274 while (Remain > 0) {
2275 if (Remain < RW_Block_Size)
bigbiffce8f83c2015-12-12 18:30:21 -05002276 bs = (ssize_t)(Remain);
2277 if (read(src_fd, buffer, bs) != bs) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002278 LOGINFO("Error reading source fd (%s)\n", strerror(errno));
2279 goto exit;
2280 }
2281 if (write(dest_fd, buffer, bs) != bs) {
2282 LOGINFO("Error writing destination fd (%s)\n", strerror(errno));
2283 goto exit;
2284 }
2285 backedup_size += (unsigned long long)(bs);
bigbiffce8f83c2015-12-12 18:30:21 -05002286 Remain = Remain - (unsigned long long)(bs);
2287 if (part_settings->progress)
2288 part_settings->progress->UpdateSize(backedup_size);
Ethan Yonker472f5062016-02-25 13:47:30 -06002289 if (PartitionManager.Check_Backup_Cancel() != 0)
2290 goto exit;
2291 }
bigbiffce8f83c2015-12-12 18:30:21 -05002292 if (part_settings->progress)
2293 part_settings->progress->UpdateDisplayDetails(true);
Ethan Yonker472f5062016-02-25 13:47:30 -06002294 fsync(dest_fd);
2295 ret = true;
2296exit:
2297 if (src_fd >= 0)
2298 close(src_fd);
2299 if (dest_fd >= 0)
2300 close(dest_fd);
2301 if (buffer)
2302 free(buffer);
2303 return ret;
2304}
2305
bigbiffce8f83c2015-12-12 18:30:21 -05002306bool TWPartition::Backup_Dump_Image(PartitionSettings *part_settings) {
Vojtech Bocek05534202013-09-11 08:11:56 +02002307 string Full_FileName, Command;
bigbiffce8f83c2015-12-12 18:30:21 -05002308 int use_compression, adb_control_bu_fd;
2309 unsigned long long compressed;
Dees_Troy43d8b002012-09-17 16:00:01 -04002310
Ethan Yonker74db1572015-10-28 12:44:49 -05002311 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2312 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002313
bigbiffce8f83c2015-12-12 18:30:21 -05002314 if (part_settings->progress)
2315 part_settings->progress->SetPartitionSize(Backup_Size);
Dees_Troy43d8b002012-09-17 16:00:01 -04002316
Ethan Yonker472f5062016-02-25 13:47:30 -06002317 Backup_FileName = Backup_Name + "." + Current_File_System + ".win";
bigbiffce8f83c2015-12-12 18:30:21 -05002318 Full_FileName = part_settings->Full_Backup_Path + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04002319
2320 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
bigbiffce8f83c2015-12-12 18:30:21 -05002321
Dees_Troy2673cec2013-04-02 20:22:16 +00002322 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002323 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002324 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002325 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2326 // 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 -06002327 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002328 return false;
2329 }
bigbiffce8f83c2015-12-12 18:30:21 -05002330 if (part_settings->progress)
2331 part_settings->progress->UpdateSize(Backup_Size);
2332
Dees_Troy43d8b002012-09-17 16:00:01 -04002333 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002334}
2335
bigbiffce8f83c2015-12-12 18:30:21 -05002336unsigned long long TWPartition::Get_Restore_Size(PartitionSettings *part_settings) {
2337 if (!part_settings->adbbackup) {
2338 InfoManager restore_info(part_settings->Restore_Name + "/" + Backup_Name + ".info");
2339 if (restore_info.LoadValues() == 0) {
2340 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2341 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2342 return Restore_Size;
2343 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002344 }
2345 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002346
bigbiffce8f83c2015-12-12 18:30:21 -05002347 string Full_FileName, Restore_File_System = Get_Restore_File_System(part_settings);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002348
bigbiffce8f83c2015-12-12 18:30:21 -05002349 Full_FileName = part_settings->Restore_Name + "/" + Backup_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002350 if (Is_Image(Restore_File_System)) {
2351 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2352 return Restore_Size;
2353 }
2354
2355 twrpTar tar;
2356 tar.setdir(Backup_Path);
2357 tar.setfn(Full_FileName);
bigbiffce8f83c2015-12-12 18:30:21 -05002358 tar.backup_name = Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002359#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2360 string Password;
2361 DataManager::GetValue("tw_restore_password", Password);
2362 if (!Password.empty())
2363 tar.setpassword(Password);
2364#endif
2365 tar.partition_name = Backup_Name;
bigbiffce8f83c2015-12-12 18:30:21 -05002366 tar.backup_folder = part_settings->Restore_Name;
2367 tar.part_settings = part_settings;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002368 Restore_Size = tar.get_size();
2369 return Restore_Size;
2370}
2371
bigbiffce8f83c2015-12-12 18:30:21 -05002372bool TWPartition::Restore_Tar(PartitionSettings *part_settings) {
Ethan Yonker472f5062016-02-25 13:47:30 -06002373 string Full_FileName;
Dees Troy4159aed2014-02-28 17:24:43 +00002374 bool ret = false;
bigbiffce8f83c2015-12-12 18:30:21 -05002375 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002376
Dees_Troye58d5262012-09-21 12:27:57 -04002377 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002378 if (!Wipe_AndSec())
2379 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002380 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002381 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002382 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002383 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 -05002384 if (!Wipe_Data_Without_Wiping_Media())
2385 return false;
2386 } else {
2387 if (!Wipe(Restore_File_System))
2388 return false;
2389 }
Dees_Troye58d5262012-09-21 12:27:57 -04002390 }
Matt Mower3c366972015-12-25 19:28:31 -06002391 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002392 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002393
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002394 // Remount as read/write as needed so we can restore the backup
2395 if (!ReMount_RW(true))
Dees_Troy43d8b002012-09-17 16:00:01 -04002396 return false;
2397
bigbiffce8f83c2015-12-12 18:30:21 -05002398 Full_FileName = part_settings->Restore_Name + "/" + part_settings->Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002399 twrpTar tar;
bigbiffce8f83c2015-12-12 18:30:21 -05002400 tar.part_settings = part_settings;
Ethan Yonker87af5632014-02-10 11:56:35 -06002401 tar.setdir(Backup_Path);
2402 tar.setfn(Full_FileName);
2403 tar.backup_name = Backup_Name;
2404#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2405 string Password;
2406 DataManager::GetValue("tw_restore_password", Password);
2407 if (!Password.empty())
2408 tar.setpassword(Password);
2409#endif
bigbiffce8f83c2015-12-12 18:30:21 -05002410 part_settings->progress->SetPartitionSize(Get_Restore_Size(part_settings));
2411 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002412 ret = false;
2413 else
2414 ret = true;
2415#ifdef HAVE_CAPABILITIES
2416 // Restore capabilities to the run-as binary
2417 if (Mount_Point == "/system" && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
2418 struct vfs_cap_data cap_data;
2419 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2420
2421 memset(&cap_data, 0, sizeof(cap_data));
2422 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2423 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2424 cap_data.data[0].inheritable = 0;
2425 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2426 cap_data.data[1].inheritable = 0;
2427 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2428 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2429 } else {
2430 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2431 }
2432 }
2433#endif
James Christopher Adduonod6f94ac2016-02-29 04:26:04 -05002434 if (Mount_Read_Only || Mount_Flags & MS_RDONLY)
2435 // Remount as read only when restoration is complete
2436 ReMount(true);
2437
Dees Troy4159aed2014-02-28 17:24:43 +00002438 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002439}
2440
bigbiffce8f83c2015-12-12 18:30:21 -05002441bool TWPartition::Restore_Image(PartitionSettings *part_settings) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002442 string Full_FileName;
bigbiffce8f83c2015-12-12 18:30:21 -05002443 string Restore_File_System = Get_Restore_File_System(part_settings);
Dees_Troy43d8b002012-09-17 16:00:01 -04002444
Matt Mower3c366972015-12-25 19:28:31 -06002445 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restoring_hdr}"));
Ethan Yonker74db1572015-10-28 12:44:49 -05002446 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
bigbiffce8f83c2015-12-12 18:30:21 -05002447
2448 if (part_settings->adbbackup)
2449 Full_FileName = TW_ADB_RESTORE;
2450 else
2451 Full_FileName = part_settings->Full_Backup_Path + part_settings->Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002452
Ethan Yonker96af84a2015-01-05 14:58:36 -06002453 if (Restore_File_System == "emmc") {
bigbiffce8f83c2015-12-12 18:30:21 -05002454 if (!part_settings->adbbackup)
2455 part_settings->total_restore_size = (uint64_t)(TWFunc::Get_File_Size(Full_FileName));
2456 if (!Raw_Read_Write(part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002457 return false;
2458 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
bigbiffce8f83c2015-12-12 18:30:21 -05002459 if (!Flash_Image_FI(Full_FileName, part_settings->progress))
2460 return false;
2461 }
2462
2463 if (part_settings->adbbackup) {
2464 if (!twadbbu::Write_TWEOF())
Ethan Yonker96af84a2015-01-05 14:58:36 -06002465 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002466 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002467 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002468}
Dees_Troy5bf43922012-09-07 16:07:55 -04002469
2470bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002471 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002472
Dees_Troyab10ee22012-09-21 14:27:30 -04002473 if (!Can_Be_Mounted && !Is_Encrypted)
Dees_Troy5bf43922012-09-07 16:07:55 -04002474 return false;
2475
Dees_Troy0550cfb2012-10-13 11:56:13 -04002476 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04002477 if (Removable || Is_Encrypted) {
2478 if (!Mount(false))
2479 return true;
2480 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002481 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002482
2483 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002484 if (!ret || Size == 0) {
2485 if (!Get_Size_Via_df(Display_Error)) {
2486 if (!Was_Already_Mounted)
2487 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002488 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002489 }
2490 }
Dees_Troy51127312012-09-08 13:08:49 -04002491
Dees_Troy5bf43922012-09-07 16:07:55 -04002492 if (Has_Data_Media) {
2493 if (Mount(Display_Error)) {
Dees_Troy51127312012-09-08 13:08:49 -04002494 unsigned long long data_media_used, actual_data;
Ethan Yonker66a19492015-12-10 10:19:45 -06002495 Used = du.Get_Folder_Size(Mount_Point);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002496 Backup_Size = Used;
2497 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04002498 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002499 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002500 } else {
2501 if (!Was_Already_Mounted)
2502 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002503 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002504 }
Dees_Troye58d5262012-09-21 12:27:57 -04002505 } else if (Has_Android_Secure) {
2506 if (Mount(Display_Error))
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002507 Backup_Size = du.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002508 else {
2509 if (!Was_Already_Mounted)
2510 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04002511 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002512 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002513 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04002514 if (!Was_Already_Mounted)
2515 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002516 return true;
Dees_Troy51127312012-09-08 13:08:49 -04002517}
Dees_Troy38bd7602012-09-14 13:33:53 -04002518
2519void TWPartition::Find_Actual_Block_Device(void) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002520 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002521 Actual_Block_Device = Decrypted_Block_Device;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002522 if (TWFunc::Path_Exists(Decrypted_Block_Device))
Dees_Troy38bd7602012-09-14 13:33:53 -04002523 Is_Present = true;
Dees_Troy43d8b002012-09-17 16:00:01 -04002524 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002525 Is_Present = true;
2526 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002527 return;
2528 }
2529 if (Is_Decrypted) {
Dees_Troy43d8b002012-09-17 16:00:01 -04002530 } else if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04002531 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04002532 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002533 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04002534 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002535 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002536}
2537
2538void TWPartition::Recreate_Media_Folder(void) {
2539 string Command;
Ethan Yonker66a19492015-12-10 10:19:45 -06002540 string Media_Path = Mount_Point + "/media";
Dees_Troy38bd7602012-09-14 13:33:53 -04002541
2542 if (!Mount(true)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002543 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Media_Path));
2544 } else if (!TWFunc::Path_Exists(Media_Path)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002545 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker66a19492015-12-10 10:19:45 -06002546 LOGINFO("Recreating %s folder.\n", Media_Path.c_str());
2547 mkdir(Media_Path.c_str(), 0770);
xiaolu9416f4f2015-06-04 08:22:23 +08002548 string Internal_path = DataManager::GetStrValue("tw_internal_path");
2549 if (!Internal_path.empty()) {
2550 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
2551 mkdir(Internal_path.c_str(), 0770);
2552 }
2553#ifdef TW_INTERNAL_STORAGE_PATH
2554 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
2555#endif
Ethan Yonker5ef301e2014-10-14 10:04:44 -05002556#ifdef HAVE_SELINUX
thata3d31fb2014-12-21 22:27:40 +01002557 // Afterwards, we will try to set the
2558 // default metadata that we were hopefully able to get during
2559 // early boot.
Ethan Yonker66a19492015-12-10 10:19:45 -06002560 tw_set_default_metadata(Media_Path.c_str());
xiaolu9416f4f2015-06-04 08:22:23 +08002561 if (!Internal_path.empty())
2562 tw_set_default_metadata(Internal_path.c_str());
Ethan Yonker5ef301e2014-10-14 10:04:44 -05002563#endif
Ethan Yonker5eac2222014-06-11 12:22:55 -05002564 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002565 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05002566 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04002567 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002568}
Dees_Troye58d5262012-09-21 12:27:57 -04002569
2570void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04002571 if (!Has_Android_Secure)
2572 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00002573 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002574 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002575 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04002576 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002577 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002578 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002579 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002580 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002581 }
2582}
bigbiff7cb4c332014-11-26 20:36:07 -05002583
2584uint64_t TWPartition::Get_Max_FileSize() {
2585 uint64_t maxFileSize = 0;
2586 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
2587 const uint64_t constTB = (uint64_t) constGB * 1024;
2588 const uint64_t constPB = (uint64_t) constTB * 1024;
2589 const uint64_t constEB = (uint64_t) constPB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05002590 if (Current_File_System == "ext4")
2591 maxFileSize = 16 * constTB; //16 TB
2592 else if (Current_File_System == "vfat")
2593 maxFileSize = 4 * constGB; //4 GB
2594 else if (Current_File_System == "ntfs")
2595 maxFileSize = 256 * constTB; //256 TB
2596 else if (Current_File_System == "exfat")
2597 maxFileSize = 16 * constPB; //16 PB
2598 else if (Current_File_System == "ext3")
2599 maxFileSize = 2 * constTB; //2 TB
2600 else if (Current_File_System == "f2fs")
2601 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05002602 else
2603 maxFileSize = 100000000L;
2604 return maxFileSize - 1;
2605}
2606
bigbiffce8f83c2015-12-12 18:30:21 -05002607bool TWPartition::Flash_Image(PartitionSettings *part_settings) {
2608 string Restore_File_System, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002609
bigbiffce8f83c2015-12-12 18:30:21 -05002610 full_filename = part_settings->Restore_Name + "/" + part_settings->Backup_FileName;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002611
bigbiffce8f83c2015-12-12 18:30:21 -05002612 LOGINFO("Image filename is: %s\n", part_settings->Backup_FileName.c_str());
2613
2614 if (Backup_Method == BM_FILES) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002615 LOGERR("Cannot flash images to file systems\n");
2616 return false;
2617 } else if (!Can_Flash_Img) {
2618 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
2619 return false;
2620 } else {
2621 if (!Find_Partition_Size()) {
2622 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
2623 return false;
2624 }
bigbiffce8f83c2015-12-12 18:30:21 -05002625 unsigned long long image_size = TWFunc::Get_File_Size(full_filename);
Ethan Yonker96af84a2015-01-05 14:58:36 -06002626 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002627 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
bigbiffce8f83c2015-12-12 18:30:21 -05002628 image_size, part_settings->Backup_FileName.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05002629 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002630 return false;
2631 }
bigbiffce8f83c2015-12-12 18:30:21 -05002632 if (Backup_Method == BM_DD) {
2633 if (!part_settings->adbbackup) {
2634 if (Is_Sparse_Image(full_filename)) {
2635 return Flash_Sparse_Image(full_filename);
2636 }
Ethan Yonker472f5062016-02-25 13:47:30 -06002637 }
bigbiffce8f83c2015-12-12 18:30:21 -05002638 unsigned long long file_size = (unsigned long long)(TWFunc::Get_File_Size(full_filename));
2639 return Raw_Read_Write(part_settings);
2640 } else if (Backup_Method == BM_FLASH_UTILS) {
2641 return Flash_Image_FI(full_filename, NULL);
Ethan Yonker472f5062016-02-25 13:47:30 -06002642 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002643 }
2644
2645 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
2646 return false;
2647}
2648
Ethan Yonker472f5062016-02-25 13:47:30 -06002649bool TWPartition::Is_Sparse_Image(const string& Filename) {
HashBanged974bb2016-01-30 14:20:09 -05002650 uint32_t magic = 0;
2651 int fd = open(Filename.c_str(), O_RDONLY);
2652 if (fd < 0) {
2653 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
2654 return false;
2655 }
bigbiffce8f83c2015-12-12 18:30:21 -05002656
HashBanged974bb2016-01-30 14:20:09 -05002657 if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
2658 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Filename)(strerror(errno)));
2659 close(fd);
2660 return false;
2661 }
2662 close(fd);
Ethan Yonker472f5062016-02-25 13:47:30 -06002663 if (magic == SPARSE_HEADER_MAGIC)
2664 return true;
2665 return false;
2666}
2667
2668bool TWPartition::Flash_Sparse_Image(const string& Filename) {
2669 string Command;
2670
2671 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
2672
2673 Command = "simg2img '" + Filename + "' '" + Actual_Block_Device + "'";
Ethan Yonker96af84a2015-01-05 14:58:36 -06002674 LOGINFO("Flash command: '%s'\n", Command.c_str());
2675 TWFunc::Exec_Cmd(Command);
2676 return true;
2677}
2678
Ethan Yonker472f5062016-02-25 13:47:30 -06002679bool TWPartition::Flash_Image_FI(const string& Filename, ProgressTracking *progress) {
Ethan Yonker96af84a2015-01-05 14:58:36 -06002680 string Command;
Ethan Yonker472f5062016-02-25 13:47:30 -06002681 unsigned long long file_size;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002682
Ethan Yonker74db1572015-10-28 12:44:49 -05002683 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker472f5062016-02-25 13:47:30 -06002684 if (progress) {
2685 file_size = (unsigned long long)(TWFunc::Get_File_Size(Filename));
2686 progress->SetPartitionSize(file_size);
2687 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002688 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
2689 Command = "erase_image " + MTD_Name;
2690 LOGINFO("Erase command: '%s'\n", Command.c_str());
2691 TWFunc::Exec_Cmd(Command);
2692 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
2693 LOGINFO("Flash command: '%s'\n", Command.c_str());
2694 TWFunc::Exec_Cmd(Command);
Ethan Yonker472f5062016-02-25 13:47:30 -06002695 if (progress)
2696 progress->UpdateSize(file_size);
Ethan Yonker96af84a2015-01-05 14:58:36 -06002697 return true;
2698}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05002699
2700void TWPartition::Change_Mount_Read_Only(bool new_value) {
2701 Mount_Read_Only = new_value;
2702}
2703
bigbiffce8f83c2015-12-12 18:30:21 -05002704bool TWPartition::Is_Read_Only() {
2705 return Mount_Read_Only;
2706}
2707
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05002708int TWPartition::Check_Lifetime_Writes() {
2709 bool original_read_only = Mount_Read_Only;
2710 int ret = 1;
2711
2712 Mount_Read_Only = true;
2713 if (Mount(false)) {
2714 Find_Actual_Block_Device();
2715 string block = basename(Actual_Block_Device.c_str());
2716 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
2717 string result;
2718 if (TWFunc::Path_Exists(file)) {
2719 if (TWFunc::read_file(file, result) != 0) {
2720 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
2721 } else {
2722 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
2723 if (result == "0") {
2724 ret = 0;
2725 }
2726 }
2727 } else {
2728 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
2729 }
2730 UnMount(true);
2731 } else {
2732 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
2733 }
2734 Mount_Read_Only = original_read_only;
2735 return ret;
2736}
Ethan Yonker66a19492015-12-10 10:19:45 -06002737
2738int TWPartition::Decrypt_Adopted() {
2739#ifdef TW_INCLUDE_CRYPTO
2740 int ret = 1;
2741 Is_Adopted_Storage = false;
2742 string Adopted_Key_File = "";
2743
2744 if (!Removable)
2745 return ret;
2746
2747 int fd = open(Alternate_Block_Device.c_str(), O_RDONLY);
2748 if (fd < 0) {
2749 LOGINFO("failed to open '%s'\n", Alternate_Block_Device.c_str());
2750 return ret;
2751 }
2752 char type_guid[80];
2753 char part_guid[80];
2754
2755 if (gpt_disk_get_partition_info(fd, 2, type_guid, part_guid) == 0) {
2756 LOGINFO("type: '%s'\n", type_guid);
2757 LOGINFO("part: '%s'\n", part_guid);
2758 Adopted_GUID = part_guid;
2759 LOGINFO("Adopted_GUID '%s'\n", Adopted_GUID.c_str());
2760 if (strcmp(type_guid, TWGptAndroidExpand) == 0) {
2761 LOGINFO("android_expand found\n");
2762 Adopted_Key_File = "/data/misc/vold/expand_";
2763 Adopted_Key_File += part_guid;
2764 Adopted_Key_File += ".key";
2765 if (TWFunc::Path_Exists(Adopted_Key_File)) {
2766 Is_Adopted_Storage = true;
2767 /* Until we find a use case for this, I think it is safe
2768 * to disable USB Mass Storage whenever adopted storage
2769 * is present.
2770 */
2771 LOGINFO("Detected adopted storage, disabling USB mass storage mode\n");
2772 DataManager::SetValue("tw_has_usb_storage", 0);
2773 }
2774 }
2775 }
2776
2777 if (Is_Adopted_Storage) {
2778 string Adopted_Block_Device = Alternate_Block_Device + "p2";
2779 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
2780 Adopted_Block_Device = Alternate_Block_Device + "2";
2781 if (!TWFunc::Path_Exists(Adopted_Block_Device)) {
2782 LOGINFO("Adopted block device does not exist\n");
2783 goto exit;
2784 }
2785 }
2786 LOGINFO("key file is '%s', block device '%s'\n", Adopted_Key_File.c_str(), Adopted_Block_Device.c_str());
2787 char crypto_blkdev[MAXPATHLEN];
2788 std::string thekey;
2789 int fdkey = open(Adopted_Key_File.c_str(), O_RDONLY);
2790 if (fdkey < 0) {
2791 LOGINFO("failed to open key file\n");
2792 goto exit;
2793 }
2794 char buf[512];
2795 ssize_t n;
2796 while ((n = read(fdkey, &buf[0], sizeof(buf))) > 0) {
2797 thekey.append(buf, n);
2798 }
2799 close(fdkey);
2800 unsigned char* key = (unsigned char*) thekey.data();
2801 cryptfs_revert_ext_volume(part_guid);
2802
2803 ret = cryptfs_setup_ext_volume(part_guid, Adopted_Block_Device.c_str(), key, thekey.size(), crypto_blkdev);
2804 if (ret == 0) {
2805 LOGINFO("adopted storage new block device: '%s'\n", crypto_blkdev);
2806 Decrypted_Block_Device = crypto_blkdev;
2807 Is_Decrypted = true;
2808 Is_Encrypted = true;
2809 Find_Actual_Block_Device();
Kjell Braden3126a112016-06-19 16:58:15 +00002810 if (!Mount_Storage_Retry(false)) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002811 LOGERR("Failed to mount decrypted adopted storage device\n");
2812 Is_Decrypted = false;
2813 Is_Encrypted = false;
2814 cryptfs_revert_ext_volume(part_guid);
2815 ret = 1;
2816 } else {
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06002817 UnMount(false);
2818 Has_Android_Secure = false;
2819 Symlink_Path = "";
2820 Symlink_Mount_Point = "";
2821 Backup_Name = Mount_Point.substr(1);
2822 Backup_Path = Mount_Point;
2823 TWPartition* sdext = PartitionManager.Find_Partition_By_Path("/sd-ext");
2824 if (sdext && sdext->Actual_Block_Device == Adopted_Block_Device) {
2825 LOGINFO("Removing /sd-ext from partition list due to adopted storage\n");
2826 PartitionManager.Remove_Partition_By_Path("/sd-ext");
2827 }
Ethan Yonker66a19492015-12-10 10:19:45 -06002828 Setup_Data_Media();
2829 Recreate_Media_Folder();
2830 Wipe_Available_in_GUI = true;
2831 Wipe_During_Factory_Reset = true;
2832 Can_Be_Backed_Up = true;
2833 Can_Encrypt_Backup = true;
2834 Use_Userdata_Encryption = true;
2835 Is_Storage = true;
2836 Storage_Name = "Adopted Storage";
2837 Is_SubPartition = true;
2838 SubPartition_Of = "/data";
2839 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
2840 DataManager::SetValue("tw_has_adopted_storage", 1);
2841 }
2842 } else {
2843 LOGERR("Failed to setup adopted storage decryption\n");
2844 }
2845 }
2846exit:
2847 return ret;
2848#else
2849 LOGINFO("Decrypt_Adopted: no crypto support\n");
2850 return 1;
2851#endif
2852}
2853
2854void TWPartition::Revert_Adopted() {
2855#ifdef TW_INCLUDE_CRYPTO
2856 if (!Adopted_GUID.empty()) {
2857 PartitionManager.Remove_MTP_Storage(Mount_Point);
2858 UnMount(false);
2859 cryptfs_revert_ext_volume(Adopted_GUID.c_str());
2860 Is_Adopted_Storage = false;
2861 Is_Encrypted = false;
2862 Is_Decrypted = false;
2863 Decrypted_Block_Device = "";
2864 Find_Actual_Block_Device();
2865 Wipe_During_Factory_Reset = false;
2866 Can_Be_Backed_Up = false;
2867 Can_Encrypt_Backup = false;
2868 Use_Userdata_Encryption = false;
2869 Is_SubPartition = false;
2870 SubPartition_Of = "";
2871 Has_Data_Media = false;
2872 Storage_Path = Mount_Point;
2873 if (!Symlink_Mount_Point.empty()) {
2874 TWPartition* Dat = PartitionManager.Find_Partition_By_Path("/data");
2875 if (Dat) {
2876 Dat->UnMount(false);
2877 Dat->Symlink_Mount_Point = Symlink_Mount_Point;
2878 }
2879 Symlink_Mount_Point = "";
2880 }
2881 }
2882#else
2883 LOGINFO("Revert_Adopted: no crypto support\n");
2884#endif
2885}