blob: 37654311b14902bbb109adbfa1e3f0ffe362f1d8 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002 Copyright 2013 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>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050027#include <iostream>
28#include <sstream>
Dees_Troy51a0e822012-09-05 15:24:24 -040029
Dees_Troy657c3092012-09-10 20:32:10 -040030#ifdef TW_INCLUDE_CRYPTO
31 #include "cutils/properties.h"
32#endif
33
bigbiff bigbiffe60683a2013-02-22 20:55:50 -050034#include "libblkid/blkid.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040035#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000036#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040037#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040038#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040039#include "twrp-functions.hpp"
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -050040#include "twrpDigest.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050041#include "twrpTar.hpp"
bigbiff bigbiff34684ff2013-12-01 21:03:45 -050042#include "twrpDU.hpp"
bigbiff bigbiff6b600f92014-01-05 18:13:43 -050043#include "fixPermissions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040044extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040045 #include "mtdutils/mtdutils.h"
46 #include "mtdutils/mounts.h"
Dees_Troy85f44ed2013-01-09 18:42:36 +000047#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
48 #include "crypto/libcrypt_samsung/include/libcrypt_samsung.h"
49#endif
Dees_Troya95f55c2013-08-17 13:14:43 +000050#ifdef USE_EXT4
51 #include "make_ext4fs.h"
52#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060053
54#ifdef TW_INCLUDE_CRYPTO
55 #ifdef TW_INCLUDE_JB_CRYPTO
56 #include "crypto/jb/cryptfs.h"
57 #else
58 #include "crypto/ics/cryptfs.h"
59 #endif
60#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040061}
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040062#ifdef HAVE_SELINUX
63#include "selinux/selinux.h"
Ethan Yonkerf27497f2014-02-09 11:48:33 -060064#include <selinux/label.h>
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040065#endif
Dees Troy4159aed2014-02-28 17:24:43 +000066#ifdef HAVE_CAPABILITIES
67#include <sys/capability.h>
68#include <sys/xattr.h>
69#include <linux/xattr.h>
70#endif
Dees_Troy51a0e822012-09-05 15:24:24 -040071
bigbiff bigbiff9c754052013-01-09 09:09:08 -050072using namespace std;
73
Dees_Troya95f55c2013-08-17 13:14:43 +000074extern struct selabel_handle *selinux_handle;
75
Hashcode62bd9e02013-11-19 21:59:42 -080076struct flag_list {
77 const char *name;
78 unsigned flag;
79};
80
81static struct flag_list mount_flags[] = {
82 { "noatime", MS_NOATIME },
83 { "noexec", MS_NOEXEC },
84 { "nosuid", MS_NOSUID },
85 { "nodev", MS_NODEV },
86 { "nodiratime", MS_NODIRATIME },
87 { "ro", MS_RDONLY },
88 { "rw", 0 },
89 { "remount", MS_REMOUNT },
90 { "bind", MS_BIND },
91 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +000092#ifdef MS_UNBINDABLE
Hashcode62bd9e02013-11-19 21:59:42 -080093 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000094#endif
95#ifdef MS_PRIVATE
Hashcode62bd9e02013-11-19 21:59:42 -080096 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000097#endif
98#ifdef MS_SLAVE
Hashcode62bd9e02013-11-19 21:59:42 -080099 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000100#endif
101#ifdef MS_SHARED
Hashcode62bd9e02013-11-19 21:59:42 -0800102 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000103#endif
Hashcode62bd9e02013-11-19 21:59:42 -0800104 { "sync", MS_SYNCHRONOUS },
105 { "defaults", 0 },
106 { 0, 0 },
107};
108
Dees_Troy51a0e822012-09-05 15:24:24 -0400109TWPartition::TWPartition(void) {
110 Can_Be_Mounted = false;
111 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500112 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200113 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400114 Wipe_During_Factory_Reset = false;
115 Wipe_Available_in_GUI = false;
116 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400117 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400118 SubPartition_Of = "";
119 Symlink_Path = "";
120 Symlink_Mount_Point = "";
121 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400122 Backup_Path = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400123 Actual_Block_Device = "";
124 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400125 Alternate_Block_Device = "";
126 Removable = false;
127 Is_Present = false;
128 Length = 0;
129 Size = 0;
130 Used = 0;
131 Free = 0;
132 Backup_Size = 0;
133 Can_Be_Encrypted = false;
134 Is_Encrypted = false;
135 Is_Decrypted = false;
136 Decrypted_Block_Device = "";
137 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500138 Backup_Display_Name = "";
139 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400140 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400141 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400142 MTD_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400143 Backup_Method = NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000144 Can_Encrypt_Backup = false;
145 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400146 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400147 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400148 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500149 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400150 Storage_Path = "";
151 Current_File_System = "";
152 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800153 Mount_Flags = 0;
154 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400155 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000156 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +0000157 Retain_Layout_Version = false;
Dees_Troy85f44ed2013-01-09 18:42:36 +0000158#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
159 EcryptFS_Password = "";
160#endif
Dees_Troy51a0e822012-09-05 15:24:24 -0400161}
162
163TWPartition::~TWPartition(void) {
164 // Do nothing
165}
166
Dees_Troy5bf43922012-09-07 16:07:55 -0400167bool TWPartition::Process_Fstab_Line(string Line, bool Display_Error) {
168 char full_line[MAX_FSTAB_LINE_LENGTH], item[MAX_FSTAB_LINE_LENGTH];
169 int line_len = Line.size(), index = 0, item_index = 0;
170 char* ptr;
Dees_Troy51127312012-09-08 13:08:49 -0400171 string Flags;
Dees_Troy5bf43922012-09-07 16:07:55 -0400172 strncpy(full_line, Line.c_str(), line_len);
Dees_Troya13d74f2013-03-24 08:54:55 -0500173 bool skip = false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400174
Dees_Troy51127312012-09-08 13:08:49 -0400175 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500176 if (full_line[index] == 34)
177 skip = !skip;
178 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400179 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400180 }
Dees_Troy7c2dec82012-09-26 09:49:14 -0400181 Mount_Point = full_line;
Dees_Troy2673cec2013-04-02 20:22:16 +0000182 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -0400183 Backup_Path = Mount_Point;
Dees_Troya13d74f2013-03-24 08:54:55 -0500184 Storage_Path = Mount_Point;
Dees_Troy70737fa2013-04-08 13:19:20 +0000185 Display_Name = full_line + 1;
186 Backup_Display_Name = Display_Name;
187 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400188 index = Mount_Point.size();
189 while (index < line_len) {
190 while (index < line_len && full_line[index] == '\0')
191 index++;
192 if (index >= line_len)
193 continue;
194 ptr = full_line + index;
195 if (item_index == 0) {
196 // File System
197 Fstab_File_System = ptr;
198 Current_File_System = ptr;
199 item_index++;
200 } else if (item_index == 1) {
201 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400202 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400203 MTD_Name = ptr;
204 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400205 } else if (Fstab_File_System == "bml") {
206 if (Mount_Point == "/boot")
207 MTD_Name = "boot";
208 else if (Mount_Point == "/recovery")
209 MTD_Name = "recovery";
210 Primary_Block_Device = ptr;
211 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000212 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 -0400213 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400214 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000215 LOGERR("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
Dees_Troy5bf43922012-09-07 16:07:55 -0400216 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000217 LOGINFO("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
Dees_Troy5bf43922012-09-07 16:07:55 -0400218 return 0;
Dees_Troy38bd7602012-09-14 13:33:53 -0400219 } else {
220 Primary_Block_Device = ptr;
221 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400222 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400223 item_index++;
224 } else if (item_index > 1) {
225 if (*ptr == '/') {
226 // Alternate Block Device
227 Alternate_Block_Device = ptr;
228 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
229 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
230 // Partition length
231 ptr += 7;
232 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400233 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
234 // Custom flags, save for later so that new values aren't overwritten by defaults
235 ptr += 6;
236 Flags = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000237 Process_Flags(Flags, Display_Error);
Dees_Troy38bd7602012-09-14 13:33:53 -0400238 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
239 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400240 } else {
241 // Unhandled data
Dees_Troy2673cec2013-04-02 20:22:16 +0000242 LOGINFO("Unhandled fstab information: '%s', %i, line: '%s'\n", ptr, index, Line.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400243 }
244 }
245 while (index < line_len && full_line[index] != '\0')
246 index++;
247 }
248
249 if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
250 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000251 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400252 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000253 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400254 return 0;
255 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400256 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400257 Setup_File_System(Display_Error);
258 if (Mount_Point == "/system") {
259 Display_Name = "System";
Dees_Troya13d74f2013-03-24 08:54:55 -0500260 Backup_Display_Name = Display_Name;
261 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400262 Wipe_Available_in_GUI = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500263 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400264 } else if (Mount_Point == "/data") {
265 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500266 Backup_Display_Name = Display_Name;
267 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400268 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400269 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500270 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000271 Can_Encrypt_Backup = true;
272 Use_Userdata_Encryption = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400273#ifdef RECOVERY_SDCARD_ON_DATA
Dees_Troya13d74f2013-03-24 08:54:55 -0500274 Storage_Name = "Internal Storage";
Dees_Troy5bf43922012-09-07 16:07:55 -0400275 Has_Data_Media = true;
Dees_Troy51127312012-09-08 13:08:49 -0400276 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500277 Is_Settings_Storage = true;
Dees_Troy51127312012-09-08 13:08:49 -0400278 Storage_Path = "/data/media";
Dees_Troy16b74352012-11-14 22:27:31 +0000279 Symlink_Path = Storage_Path;
Dees_Troy657c3092012-09-10 20:32:10 -0400280 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
281 Make_Dir("/emmc", Display_Error);
Dees_Troy657c3092012-09-10 20:32:10 -0400282 Symlink_Mount_Point = "/emmc";
283 } else {
284 Make_Dir("/sdcard", Display_Error);
Dees_Troy657c3092012-09-10 20:32:10 -0400285 Symlink_Mount_Point = "/sdcard";
286 }
Dees_Troy16b74352012-11-14 22:27:31 +0000287 if (Mount(false) && TWFunc::Path_Exists("/data/media/0")) {
288 Storage_Path = "/data/media/0";
289 Symlink_Path = Storage_Path;
290 DataManager::SetValue(TW_INTERNAL_PATH, "/data/media/0");
291 UnMount(true);
292 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400293#endif
294#ifdef TW_INCLUDE_CRYPTO
295 Can_Be_Encrypted = true;
Dees_Troy657c3092012-09-10 20:32:10 -0400296 char crypto_blkdev[255];
297 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
298 if (strcmp(crypto_blkdev, "error") != 0) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400299 DataManager::SetValue(TW_DATA_BLK_DEVICE, Primary_Block_Device);
Dees_Troy657c3092012-09-10 20:32:10 -0400300 DataManager::SetValue(TW_IS_DECRYPTED, 1);
301 Is_Encrypted = true;
302 Is_Decrypted = true;
303 Decrypted_Block_Device = crypto_blkdev;
Dees_Troy2673cec2013-04-02 20:22:16 +0000304 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
Dees_Troy657c3092012-09-10 20:32:10 -0400305 } else if (!Mount(false)) {
Ethan Yonker71413f42014-02-26 13:36:08 -0600306 if (Is_Present) {
307#ifdef TW_INCLUDE_JB_CRYPTO
308 // No extra flags needed
309#else
310 property_set("ro.crypto.fs_type", CRYPTO_FS_TYPE);
311 property_set("ro.crypto.fs_real_blkdev", CRYPTO_REAL_BLKDEV);
312 property_set("ro.crypto.fs_mnt_point", CRYPTO_MNT_POINT);
313 property_set("ro.crypto.fs_options", CRYPTO_FS_OPTIONS);
314 property_set("ro.crypto.fs_flags", CRYPTO_FS_FLAGS);
315 property_set("ro.crypto.keyfile.userdata", CRYPTO_KEY_LOC);
316#ifdef CRYPTO_SD_FS_TYPE
317 property_set("ro.crypto.sd_fs_type", CRYPTO_SD_FS_TYPE);
318 property_set("ro.crypto.sd_fs_real_blkdev", CRYPTO_SD_REAL_BLKDEV);
319 property_set("ro.crypto.sd_fs_mnt_point", EXPAND(TW_INTERNAL_STORAGE_PATH));
320#endif
321 property_set("rw.km_fips_status", "ready");
322#endif
323 if (cryptfs_check_footer() == 0) {
324 Is_Encrypted = true;
325 Is_Decrypted = false;
326 Can_Be_Mounted = false;
327 Current_File_System = "emmc";
328 Setup_Image(Display_Error);
329 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
330 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
331 DataManager::SetValue("tw_crypto_display", "");
332 } else {
333 LOGERR("Could not mount /data and unable to find crypto footer.\n");
334 }
335 } else {
336 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
337 }
Gary Peck82599a82012-11-21 16:23:12 -0800338 } else {
339 // Filesystem is not encrypted and the mount
340 // succeeded, so get it back to the original
341 // unmounted state
342 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -0400343 }
Dees_Troy9b21af72012-10-01 15:51:46 -0400344 #ifdef RECOVERY_SDCARD_ON_DATA
345 if (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))
346 Recreate_Media_Folder();
347 #endif
348#else
349 #ifdef RECOVERY_SDCARD_ON_DATA
350 Recreate_Media_Folder();
351 #endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400352#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400353 } else if (Mount_Point == "/cache") {
354 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500355 Backup_Display_Name = Display_Name;
356 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400357 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400358 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500359 Can_Be_Backed_Up = true;
Dees_Troyce2fe772012-09-28 12:34:33 -0400360 if (Mount(false) && !TWFunc::Path_Exists("/cache/recovery/.")) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000361 LOGINFO("Recreating /cache/recovery folder.\n");
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500362 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500363 return -1;
Dees_Troyb46a6842012-09-25 11:06:46 -0400364 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400365 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400366 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400367 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500368 Backup_Display_Name = Display_Name;
369 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400370 Is_SubPartition = true;
371 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400372 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500373 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000374 Can_Encrypt_Backup = true;
375 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400376 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400377 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400378 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500379 Backup_Display_Name = Display_Name;
380 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400381 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400382 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500383 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000384 Can_Encrypt_Backup = true;
385 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400386 } else if (Mount_Point == "/boot") {
387 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500388 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400389 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500390 Can_Be_Backed_Up = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400391 }
392#ifdef TW_EXTERNAL_STORAGE_PATH
393 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
394 Is_Storage = true;
395 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400396 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500397 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400398#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000399 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400400 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400401 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500402 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400403#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000404 }
Dees_Troy8170a922012-09-18 15:40:25 -0400405#ifdef TW_INTERNAL_STORAGE_PATH
406 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
407 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500408 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400409 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500410 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400411 }
412#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000413 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400414 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500415 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500416 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400417 }
418#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400419 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400420 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400421 Setup_Image(Display_Error);
Dees_Troya13d74f2013-03-24 08:54:55 -0500422 if (Mount_Point == "/boot") {
423 Display_Name = "Boot";
424 Backup_Display_Name = Display_Name;
425 Can_Be_Backed_Up = true;
426 } else if (Mount_Point == "/recovery") {
427 Display_Name = "Recovery";
428 Backup_Display_Name = Display_Name;
Dees_Troya13d74f2013-03-24 08:54:55 -0500429 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400430 }
431
Dees_Troy51127312012-09-08 13:08:49 -0400432 // Process any custom flags
433 if (Flags.size() > 0)
434 Process_Flags(Flags, Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -0400435 return true;
436}
437
Hashcode62bd9e02013-11-19 21:59:42 -0800438bool TWPartition::Process_FS_Flags(string& Options, int Flags) {
439 int i;
440 char *p;
441 char *savep;
442 char fs_options[250];
443
444 strlcpy(fs_options, Options.c_str(), sizeof(fs_options));
445 Options = "";
446
447 p = strtok_r(fs_options, ",", &savep);
448 while (p) {
449 /* Look for the flag "p" in the flag list "fl"
450 * If not found, the loop exits with fl[i].name being null.
451 */
452 for (i = 0; mount_flags[i].name; i++) {
453 if (strncmp(p, mount_flags[i].name, strlen(mount_flags[i].name)) == 0) {
454 Flags |= mount_flags[i].flag;
455 break;
456 }
457 }
458
459 if (!mount_flags[i].name) {
460 if (Options.size() > 0)
461 Options += ",";
462 Options += p;
463 }
464 p = strtok_r(NULL, ",", &savep);
465 }
466
467 return true;
468}
469
Dees_Troy51127312012-09-08 13:08:49 -0400470bool TWPartition::Process_Flags(string Flags, bool Display_Error) {
471 char flags[MAX_FSTAB_LINE_LENGTH];
Dees_Troya13d74f2013-03-24 08:54:55 -0500472 int flags_len, index = 0, ptr_len;
Dees_Troy51127312012-09-08 13:08:49 -0400473 char* ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500474 bool skip = false, has_display_name = false, has_storage_name = false, has_backup_name = false;
Dees_Troy51127312012-09-08 13:08:49 -0400475
476 strcpy(flags, Flags.c_str());
477 flags_len = Flags.size();
478 for (index = 0; index < flags_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500479 if (flags[index] == 34)
480 skip = !skip;
481 if (!skip && flags[index] == ';')
Dees_Troy51127312012-09-08 13:08:49 -0400482 flags[index] = '\0';
483 }
484
485 index = 0;
486 while (index < flags_len) {
487 while (index < flags_len && flags[index] == '\0')
488 index++;
489 if (index >= flags_len)
490 continue;
491 ptr = flags + index;
Dees_Troya13d74f2013-03-24 08:54:55 -0500492 ptr_len = strlen(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400493 if (strcmp(ptr, "removable") == 0) {
494 Removable = true;
Ethan Yonker06c3f932014-02-02 22:11:14 -0600495 } else if (strncmp(ptr, "storage", 7) == 0) {
496 if (ptr_len == 7) {
Ethan Yonker06c3f932014-02-02 22:11:14 -0600497 Is_Storage = true;
498 } else if (ptr_len == 9) {
499 ptr += 9;
500 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
501 LOGINFO("storage set to true\n");
502 Is_Storage = true;
503 } else {
504 LOGINFO("storage set to false\n");
505 Is_Storage = false;
506 }
507 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500508 } else if (strcmp(ptr, "settingsstorage") == 0) {
509 Is_Storage = true;
Matt Mowerbf4efa32014-04-14 23:25:26 -0500510 } else if (strcmp(ptr, "andsec") == 0) {
511 Has_Android_Secure = true;
Dees_Troy63c8df72012-09-10 14:02:05 -0400512 } else if (strcmp(ptr, "canbewiped") == 0) {
513 Can_Be_Wiped = true;
Hashcodedabfd492013-08-29 22:45:30 -0700514 } else if (strcmp(ptr, "usermrf") == 0) {
515 Use_Rm_Rf = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500516 } else if (ptr_len > 7 && strncmp(ptr, "backup=", 7) == 0) {
517 ptr += 7;
518 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y')
519 Can_Be_Backed_Up = true;
520 else
521 Can_Be_Backed_Up = false;
Dees_Troy63c8df72012-09-10 14:02:05 -0400522 } else if (strcmp(ptr, "wipeingui") == 0) {
523 Can_Be_Wiped = true;
524 Wipe_Available_in_GUI = true;
525 } else if (strcmp(ptr, "wipeduringfactoryreset") == 0) {
526 Can_Be_Wiped = true;
527 Wipe_Available_in_GUI = true;
528 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500529 } else if (ptr_len > 15 && strncmp(ptr, "subpartitionof=", 15) == 0) {
Dees_Troy2c4c26f2013-01-28 15:26:43 +0000530 ptr += 15;
Dees_Troy51127312012-09-08 13:08:49 -0400531 Is_SubPartition = true;
532 SubPartition_Of = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000533 } else if (strcmp(ptr, "ignoreblkid") == 0) {
534 Ignore_Blkid = true;
Dees_Troy16c2b312013-01-15 16:51:18 +0000535 } else if (strcmp(ptr, "retainlayoutversion") == 0) {
536 Retain_Layout_Version = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500537 } else if (ptr_len > 8 && strncmp(ptr, "symlink=", 8) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400538 ptr += 8;
539 Symlink_Path = ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500540 } else if (ptr_len > 8 && strncmp(ptr, "display=", 8) == 0) {
541 has_display_name = true;
Dees_Troy51127312012-09-08 13:08:49 -0400542 ptr += 8;
Dees_Troya13d74f2013-03-24 08:54:55 -0500543 if (*ptr == '\"') ptr++;
Dees_Troy51127312012-09-08 13:08:49 -0400544 Display_Name = ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500545 if (Display_Name.substr(Display_Name.size() - 1, 1) == "\"") {
546 Display_Name.resize(Display_Name.size() - 1);
547 }
548 } else if (ptr_len > 11 && strncmp(ptr, "storagename=", 11) == 0) {
549 has_storage_name = true;
550 ptr += 11;
551 if (*ptr == '\"') ptr++;
552 Storage_Name = ptr;
553 if (Storage_Name.substr(Storage_Name.size() - 1, 1) == "\"") {
554 Storage_Name.resize(Storage_Name.size() - 1);
555 }
556 } else if (ptr_len > 11 && strncmp(ptr, "backupname=", 10) == 0) {
557 has_backup_name = true;
558 ptr += 10;
559 if (*ptr == '\"') ptr++;
560 Backup_Display_Name = ptr;
561 if (Backup_Display_Name.substr(Backup_Display_Name.size() - 1, 1) == "\"") {
562 Backup_Display_Name.resize(Backup_Display_Name.size() - 1);
563 }
564 } else if (ptr_len > 10 && strncmp(ptr, "blocksize=", 10) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400565 ptr += 10;
566 Format_Block_Size = atoi(ptr);
Dees_Troya13d74f2013-03-24 08:54:55 -0500567 } else if (ptr_len > 7 && strncmp(ptr, "length=", 7) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400568 ptr += 7;
569 Length = atoi(ptr);
Dees_Troy83bd4832013-05-04 12:39:56 +0000570 } else if (ptr_len > 17 && strncmp(ptr, "canencryptbackup=", 17) == 0) {
571 ptr += 17;
572 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y')
573 Can_Encrypt_Backup = true;
574 else
575 Can_Encrypt_Backup = false;
576 } else if (ptr_len > 21 && strncmp(ptr, "userdataencryptbackup=", 21) == 0) {
577 ptr += 21;
578 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
579 Can_Encrypt_Backup = true;
580 Use_Userdata_Encryption = true;
581 } else {
582 Use_Userdata_Encryption = false;
583 }
Hashcode62bd9e02013-11-19 21:59:42 -0800584 } else if (ptr_len > 8 && strncmp(ptr, "fsflags=", 8) == 0) {
585 ptr += 8;
586 if (*ptr == '\"') ptr++;
587
588 Mount_Options = ptr;
589 if (Mount_Options.substr(Mount_Options.size() - 1, 1) == "\"") {
590 Mount_Options.resize(Mount_Options.size() - 1);
591 }
592 Process_FS_Flags(Mount_Options, Mount_Flags);
Dees_Troy51127312012-09-08 13:08:49 -0400593 } else {
594 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000595 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400596 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000597 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400598 }
599 while (index < flags_len && flags[index] != '\0')
600 index++;
601 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500602 if (has_display_name && !has_storage_name)
603 Storage_Name = Display_Name;
604 if (!has_display_name && has_storage_name)
605 Display_Name = Storage_Name;
Dees_Troy74fb2e92013-04-15 14:35:47 +0000606 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
Dees_Troya13d74f2013-03-24 08:54:55 -0500607 Backup_Display_Name = Display_Name;
608 if (!has_display_name && has_backup_name)
609 Display_Name = Backup_Display_Name;
Dees_Troy51127312012-09-08 13:08:49 -0400610 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400611}
612
Dees_Troy5bf43922012-09-07 16:07:55 -0400613bool TWPartition::Is_File_System(string File_System) {
614 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -0400615 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400616 File_System == "ext4" ||
617 File_System == "vfat" ||
618 File_System == "ntfs" ||
619 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -0500620 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +0000621 File_System == "f2fs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400622 File_System == "auto")
623 return true;
624 else
625 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400626}
627
Dees_Troy5bf43922012-09-07 16:07:55 -0400628bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400629 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400630 return true;
631 else
632 return false;
633}
634
Dees_Troy51127312012-09-08 13:08:49 -0400635bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400636 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400637 if (mkdir(Path.c_str(), 0777) == -1) {
638 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000639 LOGERR("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400640 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000641 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400642 return false;
643 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000644 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400645 return true;
646 }
647 }
648 return true;
649}
650
Dees_Troy5bf43922012-09-07 16:07:55 -0400651void TWPartition::Setup_File_System(bool Display_Error) {
652 struct statfs st;
653
654 Can_Be_Mounted = true;
655 Can_Be_Wiped = true;
656
Dees_Troy5bf43922012-09-07 16:07:55 -0400657 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -0400658 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400659 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
660 Backup_Name = Display_Name;
661 Backup_Method = FILES;
662}
663
664void TWPartition::Setup_Image(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400665 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
666 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -0800667 if (Current_File_System == "emmc")
Dees_Troy5bf43922012-09-07 16:07:55 -0400668 Backup_Method = DD;
Gary Peck82599a82012-11-21 16:23:12 -0800669 else if (Current_File_System == "mtd" || Current_File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400670 Backup_Method = FLASH_UTILS;
671 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000672 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 -0400673 if (Find_Partition_Size()) {
674 Used = Size;
675 Backup_Size = Size;
Dees_Troy51a0e822012-09-05 15:24:24 -0400676 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400677 if (Display_Error)
Dees Troyd932ce12013-10-18 17:12:59 +0000678 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400679 else
Dees Troyd932ce12013-10-18 17:12:59 +0000680 LOGINFO("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -0400681 }
682}
683
Dees_Troye58d5262012-09-21 12:27:57 -0400684void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500685 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -0400686 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -0500687 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -0400688 Has_Android_Secure = true;
689 Symlink_Path = Mount_Point + "/.android_secure";
690 Symlink_Mount_Point = "/and-sec";
691 Backup_Path = Symlink_Mount_Point;
692 Make_Dir("/and-sec", true);
693 Recreate_AndSec_Folder();
Ethan Yonkerd4d10732014-02-03 15:27:52 -0600694 Mount_Storage_Retry();
Dees_Troye58d5262012-09-21 12:27:57 -0400695}
696
Dees_Troy5bf43922012-09-07 16:07:55 -0400697void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
698 char device[512], realDevice[512];
699
700 strcpy(device, Block.c_str());
701 memset(realDevice, 0, sizeof(realDevice));
702 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
703 {
704 strcpy(device, realDevice);
705 memset(realDevice, 0, sizeof(realDevice));
706 }
707
708 if (device[0] != '/') {
709 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000710 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400711 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000712 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400713 return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400714 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400715 Block = device;
716 return;
717 }
718}
719
Dees_Troy8e337f32012-10-13 22:07:49 -0400720void TWPartition::Mount_Storage_Retry(void) {
721 // On some devices, storage doesn't want to mount right away, retry and sleep
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500722 if (!Mount(true)) {
Dees_Troy8e337f32012-10-13 22:07:49 -0400723 int retry_count = 5;
724 while (retry_count > 0 && !Mount(false)) {
725 usleep(500000);
726 retry_count--;
727 }
728 Mount(true);
729 }
730}
731
Dees_Troy38bd7602012-09-14 13:33:53 -0400732bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
733 FILE *fp = NULL;
734 char line[255];
735
736 fp = fopen("/proc/mtd", "rt");
737 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000738 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400739 return false;
740 }
741
742 while (fgets(line, sizeof(line), fp) != NULL)
743 {
744 char device[32], label[32];
745 unsigned long size = 0;
746 char* fstype = NULL;
747 int deviceId;
748
749 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
750
751 // Skip header and blank lines
752 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
753 continue;
754
755 // Strip off the trailing " from the label
756 label[strlen(label)-1] = '\0';
757
758 if (strcmp(label, MTD_Name.c_str()) == 0) {
759 // We found our device
760 // Strip off the trailing : from the device
761 device[strlen(device)-1] = '\0';
762 if (sscanf(device,"mtd%d", &deviceId) == 1) {
763 sprintf(device, "/dev/block/mtdblock%d", deviceId);
764 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +0000765 fclose(fp);
766 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -0400767 }
768 }
769 }
770 fclose(fp);
771
772 return false;
773}
774
Dees_Troy51127312012-09-08 13:08:49 -0400775bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
776 struct statfs st;
777 string Local_Path = Mount_Point + "/.";
778
779 if (!Mount(Display_Error))
780 return false;
781
782 if (statfs(Local_Path.c_str(), &st) != 0) {
783 if (!Removable) {
784 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000785 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400786 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000787 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400788 }
789 return false;
790 }
791 Size = (st.f_blocks * st.f_bsize);
792 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
793 Free = (st.f_bfree * st.f_bsize);
794 Backup_Size = Used;
795 return true;
796}
797
798bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400799 FILE* fp;
800 char command[255], line[512];
801 int include_block = 1;
802 unsigned int min_len;
803
804 if (!Mount(Display_Error))
805 return false;
806
Dees_Troy38bd7602012-09-14 13:33:53 -0400807 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -0400808 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +0200809 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -0400810 fp = fopen("/tmp/dfoutput.txt", "rt");
811 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000812 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400813 return false;
Dees_Troy51127312012-09-08 13:08:49 -0400814 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400815
816 while (fgets(line, sizeof(line), fp) != NULL)
817 {
818 unsigned long blocks, used, available;
819 char device[64];
820 char tmpString[64];
821
822 if (strncmp(line, "Filesystem", 10) == 0)
823 continue;
824 if (strlen(line) < min_len) {
825 include_block = 0;
826 continue;
827 }
828 if (include_block) {
829 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
830 } else {
831 // The device block string is so long that the df information is on the next line
832 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -0400833 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400834 while (tmpString[space_count] == 32)
835 space_count++;
836 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
837 }
838
839 // Adjust block size to byte size
840 Size = blocks * 1024ULL;
841 Used = used * 1024ULL;
842 Free = available * 1024ULL;
843 Backup_Size = Used;
844 }
845 fclose(fp);
846 return true;
847}
848
Dees_Troy5bf43922012-09-07 16:07:55 -0400849bool TWPartition::Find_Partition_Size(void) {
850 FILE* fp;
851 char line[512];
852 string tmpdevice;
853
igoriok87e3d932013-01-31 21:03:53 +0200854 fp = fopen("/proc/dumchar_info", "rt");
855 if (fp != NULL) {
856 while (fgets(line, sizeof(line), fp) != NULL)
857 {
858 char label[32], device[32];
859 unsigned long size = 0;
860
861 sscanf(line, "%s %lx %*lx %*lu %s", label, &size, device);
862
bigbiff bigbiff34684ff2013-12-01 21:03:45 -0500863 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +0200864 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
865 continue;
866
867 tmpdevice = "/dev/";
868 tmpdevice += label;
869 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
870 Size = size;
871 fclose(fp);
872 return true;
873 }
874 }
875 }
876
Dees_Troy5bf43922012-09-07 16:07:55 -0400877 // In this case, we'll first get the partitions we care about (with labels)
878 fp = fopen("/proc/partitions", "rt");
879 if (fp == NULL)
880 return false;
881
882 while (fgets(line, sizeof(line), fp) != NULL)
883 {
884 unsigned long major, minor, blocks;
885 char device[512];
886 char tmpString[64];
887
Dees_Troy63c8df72012-09-10 14:02:05 -0400888 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -0400889 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
890
891 tmpdevice = "/dev/block/";
892 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -0400893 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400894 // Adjust block size to byte size
895 Size = blocks * 1024ULL;
896 fclose(fp);
897 return true;
898 }
899 }
900 fclose(fp);
901 return false;
902}
903
Dees_Troy5bf43922012-09-07 16:07:55 -0400904bool TWPartition::Is_Mounted(void) {
905 if (!Can_Be_Mounted)
906 return false;
907
908 struct stat st1, st2;
909 string test_path;
910
911 // Check to see if the mount point directory exists
912 test_path = Mount_Point + "/.";
913 if (stat(test_path.c_str(), &st1) != 0) return false;
914
915 // Check to see if the directory above the mount point exists
916 test_path = Mount_Point + "/../.";
917 if (stat(test_path.c_str(), &st2) != 0) return false;
918
919 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
920 int ret = (st1.st_dev != st2.st_dev) ? true : false;
921
922 return ret;
923}
924
925bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000926 int exfat_mounted = 0;
927
Dees_Troy5bf43922012-09-07 16:07:55 -0400928 if (Is_Mounted()) {
929 return true;
930 } else if (!Can_Be_Mounted) {
931 return false;
932 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400933
934 Find_Actual_Block_Device();
935
936 // Check the current file system before mounting
937 Check_FS_Type();
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000938 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
Dees_Troye34c1332013-02-06 19:13:00 +0000939 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 +0000940 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000941 string result;
942 if (TWFunc::Exec_Cmd(cmd, result) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000943 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000944 Current_File_System = "vfat";
945 } else {
946#ifdef TW_NO_EXFAT_FUSE
947 UnMount(false);
948 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
949 // Some kernels let us mount vfat as exfat which doesn't work out too well
950#else
951 exfat_mounted = 1;
952#endif
953 }
954 }
Dees_Troy22042032012-12-18 21:23:08 +0000955 if (Fstab_File_System == "yaffs2") {
956 // mount an MTD partition as a YAFFS2 filesystem.
Dees_Troy76543db2013-06-19 16:24:30 +0000957 const unsigned long flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
958 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
959 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
960 if (Display_Error)
961 LOGERR("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
962 else
963 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
964 return false;
965 } else {
966 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
967 return true;
968 }
969 } else {
970 struct stat st;
971 string test_path = Mount_Point;
972 if (stat(test_path.c_str(), &st) < 0) {
973 if (Display_Error)
974 LOGERR("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
975 else
976 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
977 return false;
978 }
979 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
980 if (new_mode != st.st_mode) {
981 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
982 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
983 if (Display_Error)
984 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
985 else
986 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
987 return false;
988 }
989 }
Dees_Troy22042032012-12-18 21:23:08 +0000990 return true;
Dees_Troy76543db2013-06-19 16:24:30 +0000991 }
Dees Troy216e0422014-02-07 03:46:42 +0000992 } else if (!exfat_mounted && mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Current_File_System.c_str(), Mount_Flags, Mount_Options.c_str()) != 0 && mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Current_File_System.c_str(), Mount_Flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000993#ifdef TW_NO_EXFAT_FUSE
994 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +0000995 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000996 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +0000997 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000998 LOGERR("Unable to mount '%s'\n", Mount_Point.c_str());
Dees_Troy85f44ed2013-01-09 18:42:36 +0000999 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001000 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Hashcode62bd9e02013-11-19 21:59:42 -08001001 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(), Mount_Flags, Mount_Options.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001002 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001003 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001004 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001005#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001006 if (!Removable && Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001007 LOGERR("Unable to mount '%s'\n", Mount_Point.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001008 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001009 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1010 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 +00001011 return false;
1012#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001013 }
1014#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001015 }
1016#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
1017 string MetaEcfsFile = EXPAND(TW_EXTERNAL_STORAGE_PATH);
1018 MetaEcfsFile += "/.MetaEcfsFile";
1019 if (EcryptFS_Password.size() > 0 && PartitionManager.Mount_By_Path("/data", false) && TWFunc::Path_Exists(MetaEcfsFile)) {
1020 if (mount_ecryptfs_drive(EcryptFS_Password.c_str(), Mount_Point.c_str(), Mount_Point.c_str(), 0) != 0) {
1021 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001022 LOGERR("Unable to mount ecryptfs for '%s'\n", Mount_Point.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001023 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001024 LOGINFO("Unable to mount ecryptfs for '%s'\n", Mount_Point.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001025 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001026 LOGINFO("Successfully mounted ecryptfs for '%s'\n", Mount_Point.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001027 Is_Decrypted = true;
Dees_Troy51127312012-09-08 13:08:49 -04001028 }
Dees_Troy066eb302013-08-23 17:20:32 +00001029 } else if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
1030 if (Is_Decrypted)
1031 LOGINFO("Mounting external storage, '%s' is not encrypted\n", Mount_Point.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001032 Is_Decrypted = false;
1033 }
1034#endif
1035 if (Removable)
1036 Update_Size(Display_Error);
1037
1038 if (!Symlink_Mount_Point.empty()) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001039 string Command = "mount '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
1040 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001041 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001042 return true;
1043}
1044
1045bool TWPartition::UnMount(bool Display_Error) {
1046 if (Is_Mounted()) {
1047 int never_unmount_system;
1048
1049 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
1050 if (never_unmount_system == 1 && Mount_Point == "/system")
1051 return true; // Never unmount system if you're not supposed to unmount it
1052
Dees_Troyc8bafa12013-01-10 15:43:00 +00001053#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
1054 if (EcryptFS_Password.size() > 0) {
1055 if (unmount_ecryptfs_drive(Mount_Point.c_str()) != 0) {
1056 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001057 LOGERR("Unable to unmount ecryptfs for '%s'\n", Mount_Point.c_str());
Dees_Troyc8bafa12013-01-10 15:43:00 +00001058 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001059 LOGINFO("Unable to unmount ecryptfs for '%s'\n", Mount_Point.c_str());
Dees_Troyc8bafa12013-01-10 15:43:00 +00001060 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001061 LOGINFO("Successfully unmounted ecryptfs for '%s'\n", Mount_Point.c_str());
Dees_Troyc8bafa12013-01-10 15:43:00 +00001062 }
1063 }
1064#endif
1065
Dees_Troy38bd7602012-09-14 13:33:53 -04001066 if (!Symlink_Mount_Point.empty())
1067 umount(Symlink_Mount_Point.c_str());
1068
Dees_Troyb05ddee2013-01-28 20:24:50 +00001069 umount(Mount_Point.c_str());
1070 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001071 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001072 LOGERR("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001073 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001074 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001075 return false;
1076 } else
1077 return true;
1078 } else {
1079 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001080 }
1081}
1082
Gary Peck43acadf2012-11-21 21:19:01 -08001083bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker5eac2222014-06-11 12:22:55 -05001084 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001085 int check;
1086 string Layout_Filename = Mount_Point + "/.layout_version";
1087
Dees_Troy38bd7602012-09-14 13:33:53 -04001088 if (!Can_Be_Wiped) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001089 LOGERR("Partition '%s' cannot be wiped.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001090 return false;
1091 }
1092
Dees_Troyc51f1f92012-09-20 15:32:13 -04001093 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001094 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001095
Dees_Troyce675462013-01-09 19:48:21 +00001096#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
1097 if (Mount_Point == "/data" && Mount(false)) {
1098 if (TWFunc::Path_Exists("/data/system/edk_p_sd"))
1099 TWFunc::copy_file("/data/system/edk_p_sd", "/tmp/edk_p_sd", 0600);
1100 }
1101#endif
1102
Dees_Troy16c2b312013-01-15 16:51:18 +00001103 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
1104 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
1105 else
1106 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -04001107
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001108 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001109 wiped = Wipe_Data_Without_Wiping_Media();
Ethan Yonker5eac2222014-06-11 12:22:55 -05001110 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001111 } else {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001112
Dees_Troy16c2b312013-01-15 16:51:18 +00001113 DataManager::GetValue(TW_RM_RF_VAR, check);
1114
Hashcodedabfd492013-08-29 22:45:30 -07001115 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001116 wiped = Wipe_RMRF();
1117 else if (New_File_System == "ext4")
1118 wiped = Wipe_EXT4();
1119 else if (New_File_System == "ext2" || New_File_System == "ext3")
1120 wiped = Wipe_EXT23(New_File_System);
1121 else if (New_File_System == "vfat")
1122 wiped = Wipe_FAT();
1123 else if (New_File_System == "exfat")
1124 wiped = Wipe_EXFAT();
1125 else if (New_File_System == "yaffs2")
1126 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001127 else if (New_File_System == "f2fs")
1128 wiped = Wipe_F2FS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001129 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001130 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 +00001131 unlink("/.layout_version");
1132 return false;
1133 }
1134 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001135 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001136
Gary Pecke8bc5d72012-12-21 06:45:25 -08001137 if (wiped) {
Dees_Troyce675462013-01-09 19:48:21 +00001138#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
1139 if (Mount_Point == "/data" && Mount(false)) {
1140 if (TWFunc::Path_Exists("/tmp/edk_p_sd")) {
1141 Make_Dir("/data/system", true);
1142 TWFunc::copy_file("/tmp/edk_p_sd", "/data/system/edk_p_sd", 0600);
1143 }
1144 }
1145#endif
Dees_Troy16c2b312013-01-15 16:51:18 +00001146
Dees_Troy1c1ac442013-01-17 21:42:14 +00001147 if (Mount_Point == "/cache")
1148 DataManager::Output_Version();
1149
Dees_Troy16c2b312013-01-15 16:51:18 +00001150 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
1151 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
1152
1153 if (update_crypt) {
1154 Setup_File_System(false);
1155 if (Is_Encrypted && !Is_Decrypted) {
1156 // just wiped an encrypted partition back to its unencrypted state
1157 Is_Encrypted = false;
1158 Is_Decrypted = false;
1159 Decrypted_Block_Device = "";
1160 if (Mount_Point == "/data") {
1161 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1162 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1163 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001164 }
1165 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001166
1167 if (Mount_Point == "/data" && Has_Data_Media && recreate_media) {
1168 Recreate_Media_Folder();
1169 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001170 }
1171 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001172}
1173
Gary Peck43acadf2012-11-21 21:19:01 -08001174bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001175 if (Is_File_System(Current_File_System))
1176 return Wipe(Current_File_System);
1177 else
1178 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001179}
1180
Dees_Troye58d5262012-09-21 12:27:57 -04001181bool TWPartition::Wipe_AndSec(void) {
1182 if (!Has_Android_Secure)
1183 return false;
1184
Dees_Troye58d5262012-09-21 12:27:57 -04001185 if (!Mount(true))
1186 return false;
1187
Dees_Troy2673cec2013-04-02 20:22:16 +00001188 gui_print("Wiping %s\n", Backup_Display_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001189 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001190 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001191}
1192
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001193bool TWPartition::Can_Repair() {
1194 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/sbin/dosfsck"))
1195 return true;
1196 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/e2fsck"))
1197 return true;
1198 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/fsck.exfat"))
1199 return true;
1200 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/sbin/fsck.f2fs"))
1201 return true;
1202 return false;
1203}
1204
1205bool TWPartition::Repair() {
1206 string command;
1207
1208 if (Current_File_System == "vfat") {
1209 if (!TWFunc::Path_Exists("/sbin/dosfsck")) {
1210 gui_print("dosfsck does not exist! Cannot repair!\n");
1211 return false;
1212 }
1213 if (!UnMount(true))
1214 return false;
1215 gui_print("Repairing %s using dosfsck...\n", Display_Name.c_str());
1216 Find_Actual_Block_Device();
1217 command = "/sbin/dosfsck -y " + Actual_Block_Device;
1218 LOGINFO("Repair command: %s\n", command.c_str());
1219 if (TWFunc::Exec_Cmd(command) == 0) {
1220 gui_print("Done.\n");
1221 return true;
1222 } else {
1223 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1224 return false;
1225 }
1226 }
1227 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1228 if (!TWFunc::Path_Exists("/sbin/e2fsck")) {
1229 gui_print("e2fsck does not exist! Cannot repair!\n");
1230 return false;
1231 }
1232 if (!UnMount(true))
1233 return false;
1234 gui_print("Repairing %s using e2fsck...\n", Display_Name.c_str());
1235 Find_Actual_Block_Device();
1236 command = "/sbin/e2fsck -p " + Actual_Block_Device;
1237 LOGINFO("Repair command: %s\n", command.c_str());
1238 if (TWFunc::Exec_Cmd(command) == 0) {
1239 gui_print("Done.\n");
1240 return true;
1241 } else {
1242 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1243 return false;
1244 }
1245 }
1246 if (Current_File_System == "exfat") {
1247 if (!TWFunc::Path_Exists("/sbin/fsck.exfat")) {
1248 gui_print("fsck.exfat does not exist! Cannot repair!\n");
1249 return false;
1250 }
1251 if (!UnMount(true))
1252 return false;
1253 gui_print("Repairing %s using fsck.exfat...\n", Display_Name.c_str());
1254 Find_Actual_Block_Device();
1255 command = "/sbin/fsck.exfat " + Actual_Block_Device;
1256 LOGINFO("Repair command: %s\n", command.c_str());
1257 if (TWFunc::Exec_Cmd(command) == 0) {
1258 gui_print("Done.\n");
1259 return true;
1260 } else {
1261 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1262 return false;
1263 }
1264 }
1265 if (Current_File_System == "f2fs") {
1266 if (!TWFunc::Path_Exists("/sbin/fsck.f2fs")) {
1267 gui_print("fsck.f2fs does not exist! Cannot repair!\n");
1268 return false;
1269 }
1270 if (!UnMount(true))
1271 return false;
1272 gui_print("Repairing %s using fsck.f2fs...\n", Display_Name.c_str());
1273 Find_Actual_Block_Device();
1274 command = "/sbin/fsck.f2fs " + Actual_Block_Device;
1275 LOGINFO("Repair command: %s\n", command.c_str());
1276 if (TWFunc::Exec_Cmd(command) == 0) {
1277 gui_print("Done.\n");
1278 return true;
1279 } else {
1280 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1281 return false;
1282 }
1283 }
1284 return false;
1285}
1286
Dees_Troy51a0e822012-09-05 15:24:24 -04001287bool TWPartition::Backup(string backup_folder) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001288 if (Backup_Method == FILES)
1289 return Backup_Tar(backup_folder);
1290 else if (Backup_Method == DD)
1291 return Backup_DD(backup_folder);
1292 else if (Backup_Method == FLASH_UTILS)
1293 return Backup_Dump_Image(backup_folder);
Dees_Troy2673cec2013-04-02 20:22:16 +00001294 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001295 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001296}
1297
Dees_Troy43d8b002012-09-17 16:00:01 -04001298bool TWPartition::Check_MD5(string restore_folder) {
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001299 string Full_Filename, md5file;
Dees_Troy43d8b002012-09-17 16:00:01 -04001300 char split_filename[512];
1301 int index = 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001302 twrpDigest md5sum;
Dees_Troy43d8b002012-09-17 16:00:01 -04001303
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001304 memset(split_filename, 0, sizeof(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001305 Full_Filename = restore_folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04001306 if (!TWFunc::Path_Exists(Full_Filename)) {
1307 // This is a split archive, we presume
1308 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
Dees_Troy2673cec2013-04-02 20:22:16 +00001309 LOGINFO("split_filename: %s\n", split_filename);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001310 md5file = split_filename;
1311 md5file += ".md5";
1312 if (!TWFunc::Path_Exists(md5file)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001313 LOGERR("No md5 file found for '%s'.\n", split_filename);
1314 LOGERR("Please unselect Enable MD5 verification to restore.\n");
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001315 return false;
1316 }
1317 md5sum.setfn(split_filename);
Dees_Troy83bd4832013-05-04 12:39:56 +00001318 while (index < 1000) {
1319 if (TWFunc::Path_Exists(split_filename) && md5sum.verify_md5digest() != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001320 LOGERR("MD5 failed to match on '%s'.\n", split_filename);
Dees_Troy43d8b002012-09-17 16:00:01 -04001321 return false;
1322 }
1323 index++;
1324 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001325 md5sum.setfn(split_filename);
Dees_Troy43d8b002012-09-17 16:00:01 -04001326 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001327 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001328 } else {
1329 // Single file archive
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001330 md5file = Full_Filename + ".md5";
1331 if (!TWFunc::Path_Exists(md5file)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001332 LOGERR("No md5 file found for '%s'.\n", Full_Filename.c_str());
1333 LOGERR("Please unselect Enable MD5 verification to restore.\n");
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001334 return false;
1335 }
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001336 md5sum.setfn(Full_Filename);
1337 if (md5sum.verify_md5digest() != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001338 LOGERR("MD5 failed to match on '%s'.\n", Full_Filename.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001339 return false;
1340 } else
1341 return true;
1342 }
1343 return false;
1344}
1345
Dees_Troy51a0e822012-09-05 15:24:24 -04001346bool TWPartition::Restore(string restore_folder) {
Gary Peck43acadf2012-11-21 21:19:01 -08001347 size_t first_period, second_period;
1348 string Restore_File_System;
1349
1350 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
Dees_Troy2673cec2013-04-02 20:22:16 +00001351 LOGINFO("Restore filename is: %s\n", Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001352
1353 // Parse backup filename to extract the file system before wiping
1354 first_period = Backup_FileName.find(".");
1355 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001356 LOGERR("Unable to find file system (first period).\n");
Gary Peck43acadf2012-11-21 21:19:01 -08001357 return false;
1358 }
1359 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
1360 second_period = Restore_File_System.find(".");
1361 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001362 LOGERR("Unable to find file system (second period).\n");
Gary Peck43acadf2012-11-21 21:19:01 -08001363 return false;
1364 }
1365 Restore_File_System.resize(second_period);
Dees_Troy2673cec2013-04-02 20:22:16 +00001366 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001367
1368 if (Is_File_System(Restore_File_System))
1369 return Restore_Tar(restore_folder, Restore_File_System);
1370 else if (Is_Image(Restore_File_System)) {
1371 if (Restore_File_System == "emmc")
1372 return Restore_DD(restore_folder);
1373 else if (Restore_File_System == "mtd" || Restore_File_System == "bml")
1374 return Restore_Flash_Image(restore_folder);
1375 }
1376
Dees_Troy2673cec2013-04-02 20:22:16 +00001377 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001378 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001379}
1380
1381string TWPartition::Backup_Method_By_Name() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001382 if (Backup_Method == NONE)
1383 return "none";
1384 else if (Backup_Method == FILES)
1385 return "files";
1386 else if (Backup_Method == DD)
1387 return "dd";
1388 else if (Backup_Method == FLASH_UTILS)
1389 return "flash_utils";
1390 else
1391 return "undefined";
1392 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04001393}
1394
1395bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001396 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001397 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04001398 return 1;
1399}
1400
1401bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001402 bool Save_Data_Media = Has_Data_Media;
1403
1404 if (!UnMount(true))
1405 return false;
1406
Dees_Troy38bd7602012-09-14 13:33:53 -04001407 Has_Data_Media = false;
Dees_Troy74fb2e92013-04-15 14:35:47 +00001408 Decrypted_Block_Device = "";
1409 Is_Decrypted = false;
1410 Is_Encrypted = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001411 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001412 Has_Data_Media = Save_Data_Media;
1413 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
1414 Recreate_Media_Folder();
1415 }
Ethan Yonker83e82572014-04-04 10:59:28 -05001416#ifndef TW_OEM_BUILD
Dees_Troy2673cec2013-04-02 20:22:16 +00001417 gui_print("You may need to reboot recovery to be able to use /data again.\n");
Ethan Yonker83e82572014-04-04 10:59:28 -05001418#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001419 return true;
1420 } else {
1421 Has_Data_Media = Save_Data_Media;
Dees_Troy2673cec2013-04-02 20:22:16 +00001422 LOGERR("Unable to format to remove encryption.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001423 return false;
1424 }
1425 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001426}
1427
1428void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001429 const char* type;
1430 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04001431
Dees_Troy68cab492012-12-12 19:29:35 +00001432 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1433 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001434
Dees_Troy38bd7602012-09-14 13:33:53 -04001435 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001436 if (!Is_Present)
1437 return;
Dees_Troy51127312012-09-08 13:08:49 -04001438
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001439 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
1440 if (blkid_do_fullprobe(pr)) {
1441 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001442 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001443 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001444 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001445
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001446 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001447 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001448 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001449 return;
1450 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001451
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001452 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001453 blkid_free_probe(pr);
Dees_Troy51a0e822012-09-05 15:24:24 -04001454}
1455
Gary Peck43acadf2012-11-21 21:19:01 -08001456bool TWPartition::Wipe_EXT23(string File_System) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001457 if (!UnMount(true))
1458 return false;
1459
Dees_Troy43d8b002012-09-17 16:00:01 -04001460 if (TWFunc::Path_Exists("/sbin/mke2fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001461 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001462
Dees_Troy2673cec2013-04-02 20:22:16 +00001463 gui_print("Formatting %s using mke2fs...\n", Display_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001464 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001465 command = "mke2fs -t " + File_System + " -m 0 " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001466 LOGINFO("mke2fs command: %s\n", command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001467 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001468 Current_File_System = File_System;
Dees_Troye58d5262012-09-21 12:27:57 -04001469 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001470 gui_print("Done.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001471 return true;
1472 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001473 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001474 return false;
1475 }
1476 } else
1477 return Wipe_RMRF();
1478
1479 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001480}
1481
1482bool TWPartition::Wipe_EXT4() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001483 if (!UnMount(true))
1484 return false;
1485
Dees_Troyb3265ab2013-08-30 02:59:14 +00001486#if defined(HAVE_SELINUX) && defined(USE_EXT4)
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001487 int ret;
1488 char *secontext = NULL;
1489
Dees_Troya95f55c2013-08-17 13:14:43 +00001490 gui_print("Formatting %s using make_ext4fs function.\n", Display_Name.c_str());
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001491
Dees Troy99c8dbf2014-03-10 16:53:58 +00001492 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001493 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
1494 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), NULL);
1495 } else {
1496 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), selinux_handle);
1497 }
1498 if (ret != 0) {
Dees_Troya95f55c2013-08-17 13:14:43 +00001499 LOGERR("Unable to wipe '%s' using function call.\n", Mount_Point.c_str());
1500 return false;
1501 } else {
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04001502 string sedir = Mount_Point + "/lost+found";
1503 PartitionManager.Mount_By_Path(sedir.c_str(), true);
1504 rmdir(sedir.c_str());
1505 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00001506 return true;
1507 }
1508#else
Dees_Troy43d8b002012-09-17 16:00:01 -04001509 if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001510 string Command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001511
Dees_Troy2673cec2013-04-02 20:22:16 +00001512 gui_print("Formatting %s using make_ext4fs...\n", Display_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001513 Find_Actual_Block_Device();
1514 Command = "make_ext4fs";
1515 if (!Is_Decrypted && Length != 0) {
1516 // Only use length if we're not decrypted
1517 char len[32];
1518 sprintf(len, "%i", Length);
1519 Command += " -l ";
1520 Command += len;
1521 }
Dees_Troy5295d582013-09-06 15:51:08 +00001522 if (TWFunc::Path_Exists("/file_contexts")) {
1523 Command += " -S /file_contexts";
1524 }
1525 Command += " -a " + Mount_Point + " " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001526 LOGINFO("make_ext4fs command: %s\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001527 if (TWFunc::Exec_Cmd(Command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001528 Current_File_System = "ext4";
Dees_Troye58d5262012-09-21 12:27:57 -04001529 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001530 gui_print("Done.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001531 return true;
1532 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001533 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001534 return false;
1535 }
1536 } else
Gary Peck43acadf2012-11-21 21:19:01 -08001537 return Wipe_EXT23("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00001538#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001539 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001540}
1541
1542bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001543 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001544
Dees_Troy43d8b002012-09-17 16:00:01 -04001545 if (TWFunc::Path_Exists("/sbin/mkdosfs")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001546 if (!UnMount(true))
1547 return false;
1548
Dees_Troy2673cec2013-04-02 20:22:16 +00001549 gui_print("Formatting %s using mkdosfs...\n", Display_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001550 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001551 command = "mkdosfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001552 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001553 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04001554 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001555 gui_print("Done.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001556 return true;
1557 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001558 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001559 return false;
1560 }
1561 return true;
1562 }
1563 else
1564 return Wipe_RMRF();
1565
1566 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001567}
1568
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001569bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001570 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001571
1572 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
1573 if (!UnMount(true))
1574 return false;
1575
Dees_Troy2673cec2013-04-02 20:22:16 +00001576 gui_print("Formatting %s using mkexfatfs...\n", Display_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001577 Find_Actual_Block_Device();
1578 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001579 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001580 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001581 gui_print("Done.\n");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001582 return true;
1583 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001584 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001585 return false;
1586 }
1587 return true;
1588 }
1589 return false;
1590}
1591
Dees_Troy38bd7602012-09-14 13:33:53 -04001592bool TWPartition::Wipe_MTD() {
1593 if (!UnMount(true))
1594 return false;
1595
Dees_Troy2673cec2013-04-02 20:22:16 +00001596 gui_print("MTD Formatting \"%s\"\n", MTD_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001597
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001598 mtd_scan_partitions();
1599 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
1600 if (mtd == NULL) {
1601 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
1602 return false;
1603 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001604
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001605 MtdWriteContext* ctx = mtd_write_partition(mtd);
1606 if (ctx == NULL) {
1607 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
1608 return false;
1609 }
1610 if (mtd_erase_blocks(ctx, -1) == -1) {
1611 mtd_write_close(ctx);
1612 LOGERR("Failed to format '%s'", MTD_Name.c_str());
1613 return false;
1614 }
1615 if (mtd_write_close(ctx) != 0) {
1616 LOGERR("Failed to close '%s'", MTD_Name.c_str());
1617 return false;
1618 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001619 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04001620 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001621 gui_print("Done.\n");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001622 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001623}
1624
1625bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001626 if (!Mount(true))
1627 return false;
1628
Dees_Troy2673cec2013-04-02 20:22:16 +00001629 gui_print("Removing all files under '%s'\n", Mount_Point.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001630 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04001631 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001632 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001633}
1634
Dees_Troye5017042013-08-29 16:38:55 +00001635bool TWPartition::Wipe_F2FS() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001636 string command;
Dees_Troye5017042013-08-29 16:38:55 +00001637
1638 if (TWFunc::Path_Exists("/sbin/mkfs.f2fs")) {
1639 if (!UnMount(true))
1640 return false;
1641
1642 gui_print("Formatting %s using mkfs.f2fs...\n", Display_Name.c_str());
1643 Find_Actual_Block_Device();
1644 command = "mkfs.f2fs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001645 if (TWFunc::Exec_Cmd(command) == 0) {
Dees_Troye5017042013-08-29 16:38:55 +00001646 Recreate_AndSec_Folder();
1647 gui_print("Done.\n");
1648 return true;
1649 } else {
1650 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
1651 return false;
1652 }
1653 return true;
1654 } else {
1655 gui_print("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
1656 return Wipe_RMRF();
1657 }
1658 return false;
1659}
1660
Dees_Troy51a0e822012-09-05 15:24:24 -04001661bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05001662#ifdef TW_OEM_BUILD
1663 // In an OEM Build we want to do a full format
1664 return Wipe_Encryption();
1665#else
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001666 string dir;
bigbiff bigbiff6b600f92014-01-05 18:13:43 -05001667 #ifdef HAVE_SELINUX
1668 fixPermissions perms;
1669 #endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001670
1671 // This handles wiping data on devices with "sdcard" in /data/media
1672 if (!Mount(true))
1673 return false;
1674
Dees_Troy2673cec2013-04-02 20:22:16 +00001675 gui_print("Wiping data without wiping /data/media ...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001676
1677 DIR* d;
1678 d = opendir("/data");
Dees_Troy16b74352012-11-14 22:27:31 +00001679 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001680 struct dirent* de;
1681 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001682 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
Dees_Troy16b74352012-11-14 22:27:31 +00001683 // The media folder is the "internal sdcard"
1684 // The .layout_version file is responsible for determining whether 4.2 decides up upgrade
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001685 // the media folder for multi-user.
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001686 //TODO: convert this to use twrpDU.cpp
Dees_Troy16b74352012-11-14 22:27:31 +00001687 if (strcmp(de->d_name, "media") == 0 || strcmp(de->d_name, ".layout_version") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001688
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001689 dir = "/data/";
1690 dir.append(de->d_name);
Dees_Troyce675462013-01-09 19:48:21 +00001691 if (de->d_type == DT_DIR) {
1692 TWFunc::removeDir(dir, false);
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05001693 } 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 +00001694 if (!unlink(dir.c_str()))
Dees_Troy2673cec2013-04-02 20:22:16 +00001695 LOGINFO("Unable to unlink '%s'\n", dir.c_str());
Dees_Troyce675462013-01-09 19:48:21 +00001696 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001697 }
1698 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001699
bigbiff bigbiff6b600f92014-01-05 18:13:43 -05001700 #ifdef HAVE_SELINUX
1701 perms.fixDataInternalContexts();
1702 #endif
1703
Dees_Troy2673cec2013-04-02 20:22:16 +00001704 gui_print("Done.\n");
Dees_Troy16b74352012-11-14 22:27:31 +00001705 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001706 }
Dees_Troy2673cec2013-04-02 20:22:16 +00001707 gui_print("Dirent failed to open /data, error!\n");
Dees_Troy16b74352012-11-14 22:27:31 +00001708 return false;
Ethan Yonker83e82572014-04-04 10:59:28 -05001709#endif // ifdef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -04001710}
1711
1712bool TWPartition::Backup_Tar(string backup_folder) {
Dees_Troy4a2a1262012-09-18 09:33:47 -04001713 char back_name[255], split_index[5];
1714 string Full_FileName, Split_FileName, Tar_Args, Command;
Dees_Troy83bd4832013-05-04 12:39:56 +00001715 int use_compression, use_encryption = 0, index, backup_count;
Dees_Troy4a2a1262012-09-18 09:33:47 -04001716 struct stat st;
Dees_Troy7c2dec82012-09-26 09:49:14 -04001717 unsigned long long total_bsize = 0, file_size;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001718 twrpTar tar;
1719 vector <string> files;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001720
Dees_Troy43d8b002012-09-17 16:00:01 -04001721 if (!Mount(true))
1722 return false;
1723
Dees_Troya13d74f2013-03-24 08:54:55 -05001724 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, "Backing Up");
Dees_Troy2673cec2013-04-02 20:22:16 +00001725 gui_print("Backing up %s...\n", Backup_Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001726
1727 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy83bd4832013-05-04 12:39:56 +00001728 tar.use_compression = use_compression;
Matt Mowerbb81e5d2014-03-20 18:05:41 -05001729
Dees_Troy83bd4832013-05-04 12:39:56 +00001730#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
1731 DataManager::GetValue("tw_encrypt_backup", use_encryption);
1732 if (use_encryption && Can_Encrypt_Backup) {
1733 tar.use_encryption = use_encryption;
1734 if (Use_Userdata_Encryption)
1735 tar.userdata_encryption = use_encryption;
Ethan Yonker87af5632014-02-10 11:56:35 -06001736 string Password;
1737 DataManager::GetValue("tw_backup_password", Password);
1738 tar.setpassword(Password);
Dees_Troy83bd4832013-05-04 12:39:56 +00001739 } else {
1740 use_encryption = false;
1741 }
1742#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04001743
1744 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1745 Backup_FileName = back_name;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001746 Full_FileName = backup_folder + "/" + Backup_FileName;
Dees_Troy83bd4832013-05-04 12:39:56 +00001747 tar.has_data_media = Has_Data_Media;
Dees Troye0a433a2013-12-02 04:10:37 +00001748 Full_FileName = backup_folder + "/" + Backup_FileName;
1749 tar.setdir(Backup_Path);
1750 tar.setfn(Full_FileName);
1751 tar.setsize(Backup_Size);
1752 if (tar.createTarFork() != 0)
1753 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04001754 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001755}
1756
1757bool TWPartition::Backup_DD(string backup_folder) {
igoriok87e3d932013-01-31 21:03:53 +02001758 char back_name[255], backup_size[32];
Vojtech Bocek05534202013-09-11 08:11:56 +02001759 string Full_FileName, Command, DD_BS;
Dees_Troy43d8b002012-09-17 16:00:01 -04001760 int use_compression;
1761
igoriok87e3d932013-01-31 21:03:53 +02001762 sprintf(backup_size, "%llu", Backup_Size);
1763 DD_BS = backup_size;
1764
Dees_Troyb46a6842012-09-25 11:06:46 -04001765 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
Dees_Troy2673cec2013-04-02 20:22:16 +00001766 gui_print("Backing up %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001767
1768 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1769 Backup_FileName = back_name;
1770
1771 Full_FileName = backup_folder + "/" + Backup_FileName;
1772
igoriok87e3d932013-01-31 21:03:53 +02001773 Command = "dd if=" + Actual_Block_Device + " of='" + Full_FileName + "'" + " bs=" + DD_BS + "c count=1";
Dees_Troy2673cec2013-04-02 20:22:16 +00001774 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001775 TWFunc::Exec_Cmd(Command);
Dees_Troyc154ac22012-10-12 15:36:47 -04001776 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001777 LOGERR("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04001778 return false;
1779 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001780 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001781}
1782
1783bool TWPartition::Backup_Dump_Image(string backup_folder) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001784 char back_name[255];
Vojtech Bocek05534202013-09-11 08:11:56 +02001785 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04001786 int use_compression;
1787
Dees_Troyb46a6842012-09-25 11:06:46 -04001788 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
Dees_Troy2673cec2013-04-02 20:22:16 +00001789 gui_print("Backing up %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001790
1791 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1792 Backup_FileName = back_name;
1793
1794 Full_FileName = backup_folder + "/" + Backup_FileName;
1795
1796 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
Dees_Troy2673cec2013-04-02 20:22:16 +00001797 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001798 TWFunc::Exec_Cmd(Command);
Dees_Troy7c2dec82012-09-26 09:49:14 -04001799 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
1800 // Actual size may not match backup size due to bad blocks on MTD devices so just check for 0 bytes
Dees_Troy2673cec2013-04-02 20:22:16 +00001801 LOGERR("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04001802 return false;
1803 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001804 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001805}
1806
Gary Peck43acadf2012-11-21 21:19:01 -08001807bool TWPartition::Restore_Tar(string restore_folder, string Restore_File_System) {
1808 string Full_FileName, Command;
Dees_Troy4a2a1262012-09-18 09:33:47 -04001809 int index = 0;
1810 char split_index[5];
Dees Troy4159aed2014-02-28 17:24:43 +00001811 bool ret = false;
Dees_Troy43d8b002012-09-17 16:00:01 -04001812
Dees_Troye58d5262012-09-21 12:27:57 -04001813 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04001814 if (!Wipe_AndSec())
1815 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08001816 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001817 gui_print("Wiping %s...\n", Display_Name.c_str());
Ethan Yonker5eac2222014-06-11 12:22:55 -05001818 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
1819 gui_print("WARNING: This /data backup was made with %s file system!\n", Restore_File_System.c_str());
1820 gui_print("The backup may not boot unless you change back to %s.\n", Restore_File_System.c_str());
1821 if (!Wipe_Data_Without_Wiping_Media())
1822 return false;
1823 } else {
1824 if (!Wipe(Restore_File_System))
1825 return false;
1826 }
Dees_Troye58d5262012-09-21 12:27:57 -04001827 }
Dees_Troya13d74f2013-03-24 08:54:55 -05001828 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, "Restoring");
Dees_Troy2673cec2013-04-02 20:22:16 +00001829 gui_print("Restoring %s...\n", Backup_Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001830
1831 if (!Mount(true))
1832 return false;
1833
Dees_Troy4a2a1262012-09-18 09:33:47 -04001834 Full_FileName = restore_folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06001835 twrpTar tar;
1836 tar.setdir(Backup_Path);
1837 tar.setfn(Full_FileName);
1838 tar.backup_name = Backup_Name;
1839#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
1840 string Password;
1841 DataManager::GetValue("tw_restore_password", Password);
1842 if (!Password.empty())
1843 tar.setpassword(Password);
1844#endif
1845 if (tar.extractTarFork() != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00001846 ret = false;
1847 else
1848 ret = true;
1849#ifdef HAVE_CAPABILITIES
1850 // Restore capabilities to the run-as binary
1851 if (Mount_Point == "/system" && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
1852 struct vfs_cap_data cap_data;
1853 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
1854
1855 memset(&cap_data, 0, sizeof(cap_data));
1856 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
1857 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
1858 cap_data.data[0].inheritable = 0;
1859 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
1860 cap_data.data[1].inheritable = 0;
1861 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
1862 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
1863 } else {
1864 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
1865 }
1866 }
1867#endif
1868 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04001869}
1870
1871bool TWPartition::Restore_DD(string restore_folder) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001872 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04001873
Dees_Troyda8b55a2012-12-12 19:18:30 +00001874 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
Dees_Troy43d8b002012-09-17 16:00:01 -04001875 Full_FileName = restore_folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08001876
1877 if (!Find_Partition_Size()) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001878 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Gary Peck15e623d2012-11-21 21:07:58 -08001879 return false;
1880 }
1881 unsigned long long backup_size = TWFunc::Get_File_Size(Full_FileName);
1882 if (backup_size > Size) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001883 LOGERR("Size (%iMB) of backup '%s' is larger than target device '%s' (%iMB)\n",
Gary Peck15e623d2012-11-21 21:07:58 -08001884 (int)(backup_size / 1048576LLU), Full_FileName.c_str(),
1885 Actual_Block_Device.c_str(), (int)(Size / 1048576LLU));
1886 return false;
1887 }
1888
Dees_Troy2673cec2013-04-02 20:22:16 +00001889 gui_print("Restoring %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001890 Command = "dd bs=4096 if='" + Full_FileName + "' of=" + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001891 LOGINFO("Restore command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001892 TWFunc::Exec_Cmd(Command);
Dees_Troy43d8b002012-09-17 16:00:01 -04001893 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001894}
1895
1896bool TWPartition::Restore_Flash_Image(string restore_folder) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001897 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04001898
Dees_Troy2673cec2013-04-02 20:22:16 +00001899 gui_print("Restoring %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001900 Full_FileName = restore_folder + "/" + Backup_FileName;
1901 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
1902 Command = "erase_image " + MTD_Name;
Dees_Troy2673cec2013-04-02 20:22:16 +00001903 LOGINFO("Erase command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001904 TWFunc::Exec_Cmd(Command);
Dees_Troy43d8b002012-09-17 16:00:01 -04001905 Command = "flash_image " + MTD_Name + " '" + Full_FileName + "'";
Dees_Troy2673cec2013-04-02 20:22:16 +00001906 LOGINFO("Restore command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001907 TWFunc::Exec_Cmd(Command);
Dees_Troy43d8b002012-09-17 16:00:01 -04001908 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001909}
Dees_Troy5bf43922012-09-07 16:07:55 -04001910
1911bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04001912 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04001913
Dees_Troyab10ee22012-09-21 14:27:30 -04001914 if (!Can_Be_Mounted && !Is_Encrypted)
Dees_Troy5bf43922012-09-07 16:07:55 -04001915 return false;
1916
Dees_Troy0550cfb2012-10-13 11:56:13 -04001917 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04001918 if (Removable || Is_Encrypted) {
1919 if (!Mount(false))
1920 return true;
1921 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04001922 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001923
1924 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001925 if (!ret || Size == 0) {
1926 if (!Get_Size_Via_df(Display_Error)) {
1927 if (!Was_Already_Mounted)
1928 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04001929 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001930 }
1931 }
Dees_Troy51127312012-09-08 13:08:49 -04001932
Dees_Troy5bf43922012-09-07 16:07:55 -04001933 if (Has_Data_Media) {
1934 if (Mount(Display_Error)) {
Dees_Troy51127312012-09-08 13:08:49 -04001935 unsigned long long data_media_used, actual_data;
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001936 Used = du.Get_Folder_Size("/data");
1937 Backup_Size = Used;
1938 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04001939 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001940 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001941 } else {
1942 if (!Was_Already_Mounted)
1943 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04001944 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001945 }
Dees_Troye58d5262012-09-21 12:27:57 -04001946 } else if (Has_Android_Secure) {
1947 if (Mount(Display_Error))
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001948 Backup_Size = du.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001949 else {
1950 if (!Was_Already_Mounted)
1951 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04001952 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001953 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001954 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04001955 if (!Was_Already_Mounted)
1956 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04001957 return true;
Dees_Troy51127312012-09-08 13:08:49 -04001958}
Dees_Troy38bd7602012-09-14 13:33:53 -04001959
1960void TWPartition::Find_Actual_Block_Device(void) {
1961 if (Is_Decrypted) {
1962 Actual_Block_Device = Decrypted_Block_Device;
Dees_Troy43d8b002012-09-17 16:00:01 -04001963 if (TWFunc::Path_Exists(Primary_Block_Device))
Dees_Troy38bd7602012-09-14 13:33:53 -04001964 Is_Present = true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001965 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001966 Is_Present = true;
1967 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001968 return;
1969 }
1970 if (Is_Decrypted) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001971 } else if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04001972 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001973 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001974 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04001975 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001976 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001977}
1978
1979void TWPartition::Recreate_Media_Folder(void) {
1980 string Command;
1981
bigbiff bigbiff6b600f92014-01-05 18:13:43 -05001982 #ifdef HAVE_SELINUX
1983 fixPermissions perms;
1984 #endif
1985
Dees_Troy38bd7602012-09-14 13:33:53 -04001986 if (!Mount(true)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001987 LOGERR("Unable to recreate /data/media folder.\n");
Dees_Troyb46a6842012-09-25 11:06:46 -04001988 } else if (!TWFunc::Path_Exists("/data/media")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001989 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy2673cec2013-04-02 20:22:16 +00001990 LOGINFO("Recreating /data/media folder.\n");
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001991 mkdir("/data/media", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff6b600f92014-01-05 18:13:43 -05001992 #ifdef HAVE_SELINUX
1993 perms.fixDataInternalContexts();
1994 #endif
Ethan Yonker5eac2222014-06-11 12:22:55 -05001995 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001996 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05001997 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04001998 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001999}
Dees_Troye58d5262012-09-21 12:27:57 -04002000
2001void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04002002 if (!Has_Android_Secure)
2003 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00002004 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002005 if (!Mount(true)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002006 LOGERR("Unable to recreate %s folder.\n", Backup_Name.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002007 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002008 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002009 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002010 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002011 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002012 }
2013}