blob: ef29bb6b3635b294621a57bc50d576d78614800e [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
bigbiff7b4c7a62015-01-01 19:44:14 -050034#include "libblkid/include/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"
Ethan Yonker1b7a31b2014-07-03 15:09:22 -050044#include "infomanager.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060045#include "set_metadata.h"
Dees_Troy5bf43922012-09-07 16:07:55 -040046extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040047 #include "mtdutils/mtdutils.h"
48 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000049#ifdef USE_EXT4
50 #include "make_ext4fs.h"
51#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060052
53#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker253368a2014-11-25 15:00:52 -060054 #include "crypto/lollipop/cryptfs.h"
Ethan Yonker71413f42014-02-26 13:36:08 -060055#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040056}
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040057#ifdef HAVE_SELINUX
58#include "selinux/selinux.h"
Ethan Yonkerf27497f2014-02-09 11:48:33 -060059#include <selinux/label.h>
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040060#endif
Dees Troy4159aed2014-02-28 17:24:43 +000061#ifdef HAVE_CAPABILITIES
62#include <sys/capability.h>
63#include <sys/xattr.h>
64#include <linux/xattr.h>
65#endif
Dees_Troy51a0e822012-09-05 15:24:24 -040066
bigbiff bigbiff9c754052013-01-09 09:09:08 -050067using namespace std;
68
Dees_Troya95f55c2013-08-17 13:14:43 +000069extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050070extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000071
Hashcode62bd9e02013-11-19 21:59:42 -080072struct flag_list {
73 const char *name;
74 unsigned flag;
75};
76
77static struct flag_list mount_flags[] = {
78 { "noatime", MS_NOATIME },
79 { "noexec", MS_NOEXEC },
80 { "nosuid", MS_NOSUID },
81 { "nodev", MS_NODEV },
82 { "nodiratime", MS_NODIRATIME },
83 { "ro", MS_RDONLY },
84 { "rw", 0 },
85 { "remount", MS_REMOUNT },
86 { "bind", MS_BIND },
87 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +000088#ifdef MS_UNBINDABLE
Hashcode62bd9e02013-11-19 21:59:42 -080089 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000090#endif
91#ifdef MS_PRIVATE
Hashcode62bd9e02013-11-19 21:59:42 -080092 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000093#endif
94#ifdef MS_SLAVE
Hashcode62bd9e02013-11-19 21:59:42 -080095 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000096#endif
97#ifdef MS_SHARED
Hashcode62bd9e02013-11-19 21:59:42 -080098 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +000099#endif
Hashcode62bd9e02013-11-19 21:59:42 -0800100 { "sync", MS_SYNCHRONOUS },
101 { "defaults", 0 },
102 { 0, 0 },
103};
104
that9e0593e2014-10-08 00:01:24 +0200105TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400106 Can_Be_Mounted = false;
107 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500108 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200109 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400110 Wipe_During_Factory_Reset = false;
111 Wipe_Available_in_GUI = false;
112 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400113 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400114 SubPartition_Of = "";
115 Symlink_Path = "";
116 Symlink_Mount_Point = "";
117 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400118 Backup_Path = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400119 Actual_Block_Device = "";
120 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400121 Alternate_Block_Device = "";
122 Removable = false;
123 Is_Present = false;
124 Length = 0;
125 Size = 0;
126 Used = 0;
127 Free = 0;
128 Backup_Size = 0;
129 Can_Be_Encrypted = false;
130 Is_Encrypted = false;
131 Is_Decrypted = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600132 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400133 Decrypted_Block_Device = "";
134 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500135 Backup_Display_Name = "";
136 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400137 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400138 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400139 MTD_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400140 Backup_Method = NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000141 Can_Encrypt_Backup = false;
142 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400143 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400144 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400145 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500146 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400147 Storage_Path = "";
148 Current_File_System = "";
149 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800150 Mount_Flags = 0;
151 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400152 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000153 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +0000154 Retain_Layout_Version = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600155 Crypto_Key_Location = "footer";
Ethan Yonker726a0202014-12-16 20:01:38 -0600156 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600157 Can_Flash_Img = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400158}
159
160TWPartition::~TWPartition(void) {
161 // Do nothing
162}
163
Dees_Troy5bf43922012-09-07 16:07:55 -0400164bool TWPartition::Process_Fstab_Line(string Line, bool Display_Error) {
165 char full_line[MAX_FSTAB_LINE_LENGTH], item[MAX_FSTAB_LINE_LENGTH];
166 int line_len = Line.size(), index = 0, item_index = 0;
167 char* ptr;
Dees_Troy51127312012-09-08 13:08:49 -0400168 string Flags;
Dees_Troy5bf43922012-09-07 16:07:55 -0400169 strncpy(full_line, Line.c_str(), line_len);
Dees_Troya13d74f2013-03-24 08:54:55 -0500170 bool skip = false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400171
Dees_Troy51127312012-09-08 13:08:49 -0400172 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500173 if (full_line[index] == 34)
174 skip = !skip;
175 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400176 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400177 }
Dees_Troy7c2dec82012-09-26 09:49:14 -0400178 Mount_Point = full_line;
Dees_Troy2673cec2013-04-02 20:22:16 +0000179 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -0400180 Backup_Path = Mount_Point;
Dees_Troya13d74f2013-03-24 08:54:55 -0500181 Storage_Path = Mount_Point;
Dees_Troy70737fa2013-04-08 13:19:20 +0000182 Display_Name = full_line + 1;
183 Backup_Display_Name = Display_Name;
184 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400185 index = Mount_Point.size();
186 while (index < line_len) {
187 while (index < line_len && full_line[index] == '\0')
188 index++;
189 if (index >= line_len)
190 continue;
191 ptr = full_line + index;
192 if (item_index == 0) {
193 // File System
194 Fstab_File_System = ptr;
195 Current_File_System = ptr;
196 item_index++;
197 } else if (item_index == 1) {
198 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400199 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400200 MTD_Name = ptr;
201 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400202 } else if (Fstab_File_System == "bml") {
203 if (Mount_Point == "/boot")
204 MTD_Name = "boot";
205 else if (Mount_Point == "/recovery")
206 MTD_Name = "recovery";
207 Primary_Block_Device = ptr;
208 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000209 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 -0400210 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400211 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000212 LOGERR("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
Dees_Troy5bf43922012-09-07 16:07:55 -0400213 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000214 LOGINFO("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
Dees_Troy5bf43922012-09-07 16:07:55 -0400215 return 0;
Dees_Troy38bd7602012-09-14 13:33:53 -0400216 } else {
217 Primary_Block_Device = ptr;
218 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400219 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400220 item_index++;
221 } else if (item_index > 1) {
222 if (*ptr == '/') {
223 // Alternate Block Device
224 Alternate_Block_Device = ptr;
225 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
226 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
227 // Partition length
228 ptr += 7;
229 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400230 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
231 // Custom flags, save for later so that new values aren't overwritten by defaults
232 ptr += 6;
233 Flags = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000234 Process_Flags(Flags, Display_Error);
Dees_Troy38bd7602012-09-14 13:33:53 -0400235 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
236 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400237 } else {
238 // Unhandled data
Dees_Troy2673cec2013-04-02 20:22:16 +0000239 LOGINFO("Unhandled fstab information: '%s', %i, line: '%s'\n", ptr, index, Line.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400240 }
241 }
242 while (index < line_len && full_line[index] != '\0')
243 index++;
244 }
245
246 if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
247 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000248 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400249 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000250 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400251 return 0;
252 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400253 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400254 Setup_File_System(Display_Error);
255 if (Mount_Point == "/system") {
256 Display_Name = "System";
Dees_Troya13d74f2013-03-24 08:54:55 -0500257 Backup_Display_Name = Display_Name;
258 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400259 Wipe_Available_in_GUI = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500260 Can_Be_Backed_Up = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400261 } else if (Mount_Point == "/data") {
262 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500263 Backup_Display_Name = Display_Name;
264 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400265 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400266 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500267 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000268 Can_Encrypt_Backup = true;
269 Use_Userdata_Encryption = true;
Ethan Yonker6277c792014-09-15 14:54:30 -0500270 if (datamedia)
that9e0593e2014-10-08 00:01:24 +0200271 Setup_Data_Media();
Dees_Troy5bf43922012-09-07 16:07:55 -0400272#ifdef TW_INCLUDE_CRYPTO
273 Can_Be_Encrypted = true;
Dees_Troy657c3092012-09-10 20:32:10 -0400274 char crypto_blkdev[255];
275 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
276 if (strcmp(crypto_blkdev, "error") != 0) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400277 DataManager::SetValue(TW_DATA_BLK_DEVICE, Primary_Block_Device);
Dees_Troy657c3092012-09-10 20:32:10 -0400278 DataManager::SetValue(TW_IS_DECRYPTED, 1);
279 Is_Encrypted = true;
280 Is_Decrypted = true;
281 Decrypted_Block_Device = crypto_blkdev;
Dees_Troy2673cec2013-04-02 20:22:16 +0000282 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
Dees_Troy657c3092012-09-10 20:32:10 -0400283 } else if (!Mount(false)) {
Ethan Yonker71413f42014-02-26 13:36:08 -0600284 if (Is_Present) {
Ethan Yonker253368a2014-11-25 15:00:52 -0600285 set_partition_data(Actual_Block_Device.c_str(), Crypto_Key_Location.c_str(), Fstab_File_System.c_str());
Ethan Yonker71413f42014-02-26 13:36:08 -0600286 if (cryptfs_check_footer() == 0) {
287 Is_Encrypted = true;
288 Is_Decrypted = false;
289 Can_Be_Mounted = false;
290 Current_File_System = "emmc";
291 Setup_Image(Display_Error);
292 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
Vojtech Bocek7e11ac52015-03-05 23:21:49 +0100293 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Ethan Yonker71413f42014-02-26 13:36:08 -0600294 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
295 DataManager::SetValue("tw_crypto_display", "");
296 } else {
297 LOGERR("Could not mount /data and unable to find crypto footer.\n");
298 }
299 } else {
300 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
301 }
Gary Peck82599a82012-11-21 16:23:12 -0800302 } else {
303 // Filesystem is not encrypted and the mount
304 // succeeded, so get it back to the original
305 // unmounted state
306 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -0400307 }
Ethan Yonker6277c792014-09-15 14:54:30 -0500308 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted)))
Dees_Troy9b21af72012-10-01 15:51:46 -0400309 Recreate_Media_Folder();
Dees_Troy9b21af72012-10-01 15:51:46 -0400310#else
Ethan Yonker6277c792014-09-15 14:54:30 -0500311 if (datamedia)
312 Recreate_Media_Folder();
Dees_Troy5bf43922012-09-07 16:07:55 -0400313#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400314 } else if (Mount_Point == "/cache") {
315 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500316 Backup_Display_Name = Display_Name;
317 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400318 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400319 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500320 Can_Be_Backed_Up = true;
Dees_Troyce2fe772012-09-28 12:34:33 -0400321 if (Mount(false) && !TWFunc::Path_Exists("/cache/recovery/.")) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000322 LOGINFO("Recreating /cache/recovery folder.\n");
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500323 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500324 return -1;
Dees_Troyb46a6842012-09-25 11:06:46 -0400325 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400326 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400327 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400328 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500329 Backup_Display_Name = Display_Name;
330 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400331 Is_SubPartition = true;
332 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400333 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500334 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000335 Can_Encrypt_Backup = true;
336 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400337 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400338 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400339 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500340 Backup_Display_Name = Display_Name;
341 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400342 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400343 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500344 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000345 Can_Encrypt_Backup = true;
346 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400347 } else if (Mount_Point == "/boot") {
348 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500349 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400350 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500351 Can_Be_Backed_Up = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400352 }
353#ifdef TW_EXTERNAL_STORAGE_PATH
354 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
355 Is_Storage = true;
356 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400357 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500358 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400359#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000360 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400361 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400362 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500363 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400364#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000365 }
Dees_Troy8170a922012-09-18 15:40:25 -0400366#ifdef TW_INTERNAL_STORAGE_PATH
367 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
368 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500369 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400370 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500371 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400372 }
373#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000374 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400375 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500376 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500377 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400378 }
379#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400380 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400381 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400382 Setup_Image(Display_Error);
Dees_Troya13d74f2013-03-24 08:54:55 -0500383 if (Mount_Point == "/boot") {
384 Display_Name = "Boot";
385 Backup_Display_Name = Display_Name;
386 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600387 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500388 } else if (Mount_Point == "/recovery") {
389 Display_Name = "Recovery";
390 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600391 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500392 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400393 }
394
Dees_Troy51127312012-09-08 13:08:49 -0400395 // Process any custom flags
396 if (Flags.size() > 0)
397 Process_Flags(Flags, Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -0400398 return true;
399}
400
Hashcode62bd9e02013-11-19 21:59:42 -0800401bool TWPartition::Process_FS_Flags(string& Options, int Flags) {
402 int i;
403 char *p;
404 char *savep;
405 char fs_options[250];
406
407 strlcpy(fs_options, Options.c_str(), sizeof(fs_options));
408 Options = "";
409
410 p = strtok_r(fs_options, ",", &savep);
411 while (p) {
412 /* Look for the flag "p" in the flag list "fl"
413 * If not found, the loop exits with fl[i].name being null.
414 */
415 for (i = 0; mount_flags[i].name; i++) {
416 if (strncmp(p, mount_flags[i].name, strlen(mount_flags[i].name)) == 0) {
417 Flags |= mount_flags[i].flag;
418 break;
419 }
420 }
421
422 if (!mount_flags[i].name) {
423 if (Options.size() > 0)
424 Options += ",";
425 Options += p;
426 }
427 p = strtok_r(NULL, ",", &savep);
428 }
429
430 return true;
431}
432
Dees_Troy51127312012-09-08 13:08:49 -0400433bool TWPartition::Process_Flags(string Flags, bool Display_Error) {
434 char flags[MAX_FSTAB_LINE_LENGTH];
Dees_Troya13d74f2013-03-24 08:54:55 -0500435 int flags_len, index = 0, ptr_len;
Dees_Troy51127312012-09-08 13:08:49 -0400436 char* ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500437 bool skip = false, has_display_name = false, has_storage_name = false, has_backup_name = false;
Dees_Troy51127312012-09-08 13:08:49 -0400438
439 strcpy(flags, Flags.c_str());
440 flags_len = Flags.size();
441 for (index = 0; index < flags_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500442 if (flags[index] == 34)
443 skip = !skip;
444 if (!skip && flags[index] == ';')
Dees_Troy51127312012-09-08 13:08:49 -0400445 flags[index] = '\0';
446 }
447
448 index = 0;
449 while (index < flags_len) {
450 while (index < flags_len && flags[index] == '\0')
451 index++;
452 if (index >= flags_len)
453 continue;
454 ptr = flags + index;
Dees_Troya13d74f2013-03-24 08:54:55 -0500455 ptr_len = strlen(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400456 if (strcmp(ptr, "removable") == 0) {
457 Removable = true;
Ethan Yonker06c3f932014-02-02 22:11:14 -0600458 } else if (strncmp(ptr, "storage", 7) == 0) {
459 if (ptr_len == 7) {
Ethan Yonker06c3f932014-02-02 22:11:14 -0600460 Is_Storage = true;
461 } else if (ptr_len == 9) {
462 ptr += 9;
463 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
464 LOGINFO("storage set to true\n");
465 Is_Storage = true;
466 } else {
467 LOGINFO("storage set to false\n");
468 Is_Storage = false;
469 }
470 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500471 } else if (strcmp(ptr, "settingsstorage") == 0) {
472 Is_Storage = true;
Matt Mowerbf4efa32014-04-14 23:25:26 -0500473 } else if (strcmp(ptr, "andsec") == 0) {
474 Has_Android_Secure = true;
Dees_Troy63c8df72012-09-10 14:02:05 -0400475 } else if (strcmp(ptr, "canbewiped") == 0) {
476 Can_Be_Wiped = true;
Hashcodedabfd492013-08-29 22:45:30 -0700477 } else if (strcmp(ptr, "usermrf") == 0) {
478 Use_Rm_Rf = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500479 } else if (ptr_len > 7 && strncmp(ptr, "backup=", 7) == 0) {
480 ptr += 7;
481 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y')
482 Can_Be_Backed_Up = true;
483 else
484 Can_Be_Backed_Up = false;
Dees_Troy63c8df72012-09-10 14:02:05 -0400485 } else if (strcmp(ptr, "wipeingui") == 0) {
486 Can_Be_Wiped = true;
487 Wipe_Available_in_GUI = true;
488 } else if (strcmp(ptr, "wipeduringfactoryreset") == 0) {
489 Can_Be_Wiped = true;
490 Wipe_Available_in_GUI = true;
491 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500492 } else if (ptr_len > 15 && strncmp(ptr, "subpartitionof=", 15) == 0) {
Dees_Troy2c4c26f2013-01-28 15:26:43 +0000493 ptr += 15;
Dees_Troy51127312012-09-08 13:08:49 -0400494 Is_SubPartition = true;
495 SubPartition_Of = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000496 } else if (strcmp(ptr, "ignoreblkid") == 0) {
497 Ignore_Blkid = true;
Dees_Troy16c2b312013-01-15 16:51:18 +0000498 } else if (strcmp(ptr, "retainlayoutversion") == 0) {
499 Retain_Layout_Version = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500500 } else if (ptr_len > 8 && strncmp(ptr, "symlink=", 8) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400501 ptr += 8;
502 Symlink_Path = ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500503 } else if (ptr_len > 8 && strncmp(ptr, "display=", 8) == 0) {
504 has_display_name = true;
Dees_Troy51127312012-09-08 13:08:49 -0400505 ptr += 8;
Dees_Troya13d74f2013-03-24 08:54:55 -0500506 if (*ptr == '\"') ptr++;
Dees_Troy51127312012-09-08 13:08:49 -0400507 Display_Name = ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500508 if (Display_Name.substr(Display_Name.size() - 1, 1) == "\"") {
509 Display_Name.resize(Display_Name.size() - 1);
510 }
511 } else if (ptr_len > 11 && strncmp(ptr, "storagename=", 11) == 0) {
512 has_storage_name = true;
513 ptr += 11;
514 if (*ptr == '\"') ptr++;
515 Storage_Name = ptr;
516 if (Storage_Name.substr(Storage_Name.size() - 1, 1) == "\"") {
517 Storage_Name.resize(Storage_Name.size() - 1);
518 }
519 } else if (ptr_len > 11 && strncmp(ptr, "backupname=", 10) == 0) {
520 has_backup_name = true;
521 ptr += 10;
522 if (*ptr == '\"') ptr++;
523 Backup_Display_Name = ptr;
524 if (Backup_Display_Name.substr(Backup_Display_Name.size() - 1, 1) == "\"") {
525 Backup_Display_Name.resize(Backup_Display_Name.size() - 1);
526 }
527 } else if (ptr_len > 10 && strncmp(ptr, "blocksize=", 10) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400528 ptr += 10;
529 Format_Block_Size = atoi(ptr);
Dees_Troya13d74f2013-03-24 08:54:55 -0500530 } else if (ptr_len > 7 && strncmp(ptr, "length=", 7) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400531 ptr += 7;
532 Length = atoi(ptr);
Dees_Troy83bd4832013-05-04 12:39:56 +0000533 } else if (ptr_len > 17 && strncmp(ptr, "canencryptbackup=", 17) == 0) {
534 ptr += 17;
535 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y')
536 Can_Encrypt_Backup = true;
537 else
538 Can_Encrypt_Backup = false;
539 } else if (ptr_len > 21 && strncmp(ptr, "userdataencryptbackup=", 21) == 0) {
540 ptr += 21;
541 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
542 Can_Encrypt_Backup = true;
543 Use_Userdata_Encryption = true;
544 } else {
545 Use_Userdata_Encryption = false;
546 }
Hashcode62bd9e02013-11-19 21:59:42 -0800547 } else if (ptr_len > 8 && strncmp(ptr, "fsflags=", 8) == 0) {
548 ptr += 8;
549 if (*ptr == '\"') ptr++;
550
551 Mount_Options = ptr;
552 if (Mount_Options.substr(Mount_Options.size() - 1, 1) == "\"") {
553 Mount_Options.resize(Mount_Options.size() - 1);
554 }
555 Process_FS_Flags(Mount_Options, Mount_Flags);
Ethan Yonker253368a2014-11-25 15:00:52 -0600556 } else if ((ptr_len > 12 && strncmp(ptr, "encryptable=", 12) == 0) || (ptr_len > 13 && strncmp(ptr, "forceencrypt=", 13) == 0)) {
557 ptr += 12;
558 if (*ptr == '=') ptr++;
559 if (*ptr == '\"') ptr++;
560
561 Crypto_Key_Location = ptr;
562 if (Crypto_Key_Location.substr(Crypto_Key_Location.size() - 1, 1) == "\"") {
563 Crypto_Key_Location.resize(Crypto_Key_Location.size() - 1);
564 }
565 } else if (ptr_len > 8 && strncmp(ptr, "mounttodecrypt", 14) == 0) {
566 Mount_To_Decrypt = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600567 } else if (strncmp(ptr, "flashimg", 8) == 0) {
568 if (ptr_len == 8) {
569 Can_Flash_Img = true;
570 } else if (ptr_len == 10) {
571 ptr += 9;
572 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
573 Can_Flash_Img = true;
574 } else {
575 Can_Flash_Img = false;
576 }
577 }
Dees_Troy51127312012-09-08 13:08:49 -0400578 } else {
579 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000580 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400581 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000582 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400583 }
584 while (index < flags_len && flags[index] != '\0')
585 index++;
586 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500587 if (has_display_name && !has_storage_name)
588 Storage_Name = Display_Name;
589 if (!has_display_name && has_storage_name)
590 Display_Name = Storage_Name;
Dees_Troy74fb2e92013-04-15 14:35:47 +0000591 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
Dees_Troya13d74f2013-03-24 08:54:55 -0500592 Backup_Display_Name = Display_Name;
593 if (!has_display_name && has_backup_name)
594 Display_Name = Backup_Display_Name;
Dees_Troy51127312012-09-08 13:08:49 -0400595 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400596}
597
Dees_Troy5bf43922012-09-07 16:07:55 -0400598bool TWPartition::Is_File_System(string File_System) {
599 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -0400600 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400601 File_System == "ext4" ||
602 File_System == "vfat" ||
603 File_System == "ntfs" ||
604 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -0500605 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +0000606 File_System == "f2fs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400607 File_System == "auto")
608 return true;
609 else
610 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400611}
612
Dees_Troy5bf43922012-09-07 16:07:55 -0400613bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400614 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400615 return true;
616 else
617 return false;
618}
619
Dees_Troy51127312012-09-08 13:08:49 -0400620bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400621 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400622 if (mkdir(Path.c_str(), 0777) == -1) {
623 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000624 LOGERR("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400625 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000626 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400627 return false;
628 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000629 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400630 return true;
631 }
632 }
633 return true;
634}
635
Dees_Troy5bf43922012-09-07 16:07:55 -0400636void TWPartition::Setup_File_System(bool Display_Error) {
637 struct statfs st;
638
639 Can_Be_Mounted = true;
640 Can_Be_Wiped = true;
641
Dees_Troy5bf43922012-09-07 16:07:55 -0400642 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -0400643 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400644 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
645 Backup_Name = Display_Name;
646 Backup_Method = FILES;
647}
648
649void TWPartition::Setup_Image(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400650 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
651 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -0800652 if (Current_File_System == "emmc")
Dees_Troy5bf43922012-09-07 16:07:55 -0400653 Backup_Method = DD;
Gary Peck82599a82012-11-21 16:23:12 -0800654 else if (Current_File_System == "mtd" || Current_File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400655 Backup_Method = FLASH_UTILS;
656 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000657 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 -0400658 if (Find_Partition_Size()) {
659 Used = Size;
660 Backup_Size = Size;
Dees_Troy51a0e822012-09-05 15:24:24 -0400661 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400662 if (Display_Error)
Dees Troyd932ce12013-10-18 17:12:59 +0000663 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400664 else
Dees Troyd932ce12013-10-18 17:12:59 +0000665 LOGINFO("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -0400666 }
667}
668
Dees_Troye58d5262012-09-21 12:27:57 -0400669void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500670 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -0400671 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -0500672 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -0400673 Has_Android_Secure = true;
674 Symlink_Path = Mount_Point + "/.android_secure";
675 Symlink_Mount_Point = "/and-sec";
676 Backup_Path = Symlink_Mount_Point;
677 Make_Dir("/and-sec", true);
678 Recreate_AndSec_Folder();
Ethan Yonkerd4d10732014-02-03 15:27:52 -0600679 Mount_Storage_Retry();
Dees_Troye58d5262012-09-21 12:27:57 -0400680}
681
that9e0593e2014-10-08 00:01:24 +0200682void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -0500683 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
684 Storage_Name = "Internal Storage";
685 Has_Data_Media = true;
686 Is_Storage = true;
687 Is_Settings_Storage = true;
688 Storage_Path = "/data/media";
689 Symlink_Path = Storage_Path;
690 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
691 Make_Dir("/emmc", false);
692 Symlink_Mount_Point = "/emmc";
693 } else {
694 Make_Dir("/sdcard", false);
695 Symlink_Mount_Point = "/sdcard";
696 }
697 if (Mount(false) && TWFunc::Path_Exists("/data/media/0")) {
698 Storage_Path = "/data/media/0";
699 Symlink_Path = Storage_Path;
700 DataManager::SetValue(TW_INTERNAL_PATH, "/data/media/0");
701 UnMount(true);
702 }
Ethan Yonker6277c792014-09-15 14:54:30 -0500703 DataManager::SetValue("tw_has_internal", 1);
704 DataManager::SetValue("tw_has_data_media", 1);
705 du.add_absolute_dir("/data/media");
706}
707
Dees_Troy5bf43922012-09-07 16:07:55 -0400708void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
709 char device[512], realDevice[512];
710
711 strcpy(device, Block.c_str());
712 memset(realDevice, 0, sizeof(realDevice));
713 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
714 {
715 strcpy(device, realDevice);
716 memset(realDevice, 0, sizeof(realDevice));
717 }
718
719 if (device[0] != '/') {
720 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000721 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400722 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000723 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400724 return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400725 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400726 Block = device;
727 return;
728 }
729}
730
Dees_Troy8e337f32012-10-13 22:07:49 -0400731void TWPartition::Mount_Storage_Retry(void) {
732 // On some devices, storage doesn't want to mount right away, retry and sleep
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500733 if (!Mount(true)) {
Dees_Troy8e337f32012-10-13 22:07:49 -0400734 int retry_count = 5;
735 while (retry_count > 0 && !Mount(false)) {
736 usleep(500000);
737 retry_count--;
738 }
739 Mount(true);
740 }
741}
742
Dees_Troy38bd7602012-09-14 13:33:53 -0400743bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
744 FILE *fp = NULL;
745 char line[255];
746
747 fp = fopen("/proc/mtd", "rt");
748 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000749 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400750 return false;
751 }
752
753 while (fgets(line, sizeof(line), fp) != NULL)
754 {
755 char device[32], label[32];
756 unsigned long size = 0;
757 char* fstype = NULL;
758 int deviceId;
759
760 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
761
762 // Skip header and blank lines
763 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
764 continue;
765
766 // Strip off the trailing " from the label
767 label[strlen(label)-1] = '\0';
768
769 if (strcmp(label, MTD_Name.c_str()) == 0) {
770 // We found our device
771 // Strip off the trailing : from the device
772 device[strlen(device)-1] = '\0';
773 if (sscanf(device,"mtd%d", &deviceId) == 1) {
774 sprintf(device, "/dev/block/mtdblock%d", deviceId);
775 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +0000776 fclose(fp);
777 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -0400778 }
779 }
780 }
781 fclose(fp);
782
783 return false;
784}
785
Dees_Troy51127312012-09-08 13:08:49 -0400786bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
787 struct statfs st;
788 string Local_Path = Mount_Point + "/.";
789
790 if (!Mount(Display_Error))
791 return false;
792
793 if (statfs(Local_Path.c_str(), &st) != 0) {
794 if (!Removable) {
795 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000796 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400797 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000798 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400799 }
800 return false;
801 }
802 Size = (st.f_blocks * st.f_bsize);
803 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
804 Free = (st.f_bfree * st.f_bsize);
805 Backup_Size = Used;
806 return true;
807}
808
809bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400810 FILE* fp;
811 char command[255], line[512];
812 int include_block = 1;
813 unsigned int min_len;
814
815 if (!Mount(Display_Error))
816 return false;
817
Dees_Troy38bd7602012-09-14 13:33:53 -0400818 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -0400819 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +0200820 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -0400821 fp = fopen("/tmp/dfoutput.txt", "rt");
822 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000823 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400824 return false;
Dees_Troy51127312012-09-08 13:08:49 -0400825 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400826
827 while (fgets(line, sizeof(line), fp) != NULL)
828 {
829 unsigned long blocks, used, available;
830 char device[64];
831 char tmpString[64];
832
833 if (strncmp(line, "Filesystem", 10) == 0)
834 continue;
835 if (strlen(line) < min_len) {
836 include_block = 0;
837 continue;
838 }
839 if (include_block) {
840 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
841 } else {
842 // The device block string is so long that the df information is on the next line
843 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -0400844 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400845 while (tmpString[space_count] == 32)
846 space_count++;
847 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
848 }
849
850 // Adjust block size to byte size
851 Size = blocks * 1024ULL;
852 Used = used * 1024ULL;
853 Free = available * 1024ULL;
854 Backup_Size = Used;
855 }
856 fclose(fp);
857 return true;
858}
859
Dees_Troy5bf43922012-09-07 16:07:55 -0400860bool TWPartition::Find_Partition_Size(void) {
861 FILE* fp;
862 char line[512];
863 string tmpdevice;
864
igoriok87e3d932013-01-31 21:03:53 +0200865 fp = fopen("/proc/dumchar_info", "rt");
866 if (fp != NULL) {
867 while (fgets(line, sizeof(line), fp) != NULL)
868 {
869 char label[32], device[32];
870 unsigned long size = 0;
871
thatd43bf2d2014-09-21 23:13:02 +0200872 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +0200873
bigbiff bigbiff34684ff2013-12-01 21:03:45 -0500874 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +0200875 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
876 continue;
877
878 tmpdevice = "/dev/";
879 tmpdevice += label;
880 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
881 Size = size;
882 fclose(fp);
883 return true;
884 }
885 }
886 }
887
Dees_Troy5bf43922012-09-07 16:07:55 -0400888 // In this case, we'll first get the partitions we care about (with labels)
889 fp = fopen("/proc/partitions", "rt");
890 if (fp == NULL)
891 return false;
892
893 while (fgets(line, sizeof(line), fp) != NULL)
894 {
895 unsigned long major, minor, blocks;
896 char device[512];
897 char tmpString[64];
898
Dees_Troy63c8df72012-09-10 14:02:05 -0400899 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -0400900 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
901
902 tmpdevice = "/dev/block/";
903 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -0400904 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400905 // Adjust block size to byte size
906 Size = blocks * 1024ULL;
907 fclose(fp);
908 return true;
909 }
910 }
911 fclose(fp);
912 return false;
913}
914
Dees_Troy5bf43922012-09-07 16:07:55 -0400915bool TWPartition::Is_Mounted(void) {
916 if (!Can_Be_Mounted)
917 return false;
918
919 struct stat st1, st2;
920 string test_path;
921
922 // Check to see if the mount point directory exists
923 test_path = Mount_Point + "/.";
924 if (stat(test_path.c_str(), &st1) != 0) return false;
925
926 // Check to see if the directory above the mount point exists
927 test_path = Mount_Point + "/../.";
928 if (stat(test_path.c_str(), &st2) != 0) return false;
929
930 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
931 int ret = (st1.st_dev != st2.st_dev) ? true : false;
932
933 return ret;
934}
935
936bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000937 int exfat_mounted = 0;
938
Dees_Troy5bf43922012-09-07 16:07:55 -0400939 if (Is_Mounted()) {
940 return true;
941 } else if (!Can_Be_Mounted) {
942 return false;
943 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400944
945 Find_Actual_Block_Device();
946
947 // Check the current file system before mounting
948 Check_FS_Type();
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000949 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
Dees_Troye34c1332013-02-06 19:13:00 +0000950 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 +0000951 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000952 string result;
953 if (TWFunc::Exec_Cmd(cmd, result) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000954 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000955 Current_File_System = "vfat";
956 } else {
957#ifdef TW_NO_EXFAT_FUSE
958 UnMount(false);
959 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
960 // Some kernels let us mount vfat as exfat which doesn't work out too well
961#else
962 exfat_mounted = 1;
963#endif
964 }
965 }
Dees_Troy22042032012-12-18 21:23:08 +0000966 if (Fstab_File_System == "yaffs2") {
967 // mount an MTD partition as a YAFFS2 filesystem.
Dees_Troy76543db2013-06-19 16:24:30 +0000968 const unsigned long flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
969 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
970 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
971 if (Display_Error)
972 LOGERR("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
973 else
974 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
975 return false;
976 } else {
977 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
978 return true;
979 }
980 } else {
981 struct stat st;
982 string test_path = Mount_Point;
983 if (stat(test_path.c_str(), &st) < 0) {
984 if (Display_Error)
985 LOGERR("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
986 else
987 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
988 return false;
989 }
990 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
991 if (new_mode != st.st_mode) {
992 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
993 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
994 if (Display_Error)
995 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
996 else
997 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
998 return false;
999 }
1000 }
Dees_Troy22042032012-12-18 21:23:08 +00001001 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001002 }
Dees Troy216e0422014-02-07 03:46:42 +00001003 } 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 +00001004#ifdef TW_NO_EXFAT_FUSE
1005 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001006 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001007 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001008 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001009 LOGERR("Unable to mount '%s'\n", Mount_Point.c_str());
Dees_Troy85f44ed2013-01-09 18:42:36 +00001010 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001011 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Hashcode62bd9e02013-11-19 21:59:42 -08001012 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 +00001013 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001014 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001015 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001016#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001017 if (!Removable && Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001018 LOGERR("Unable to mount '%s'\n", Mount_Point.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001019 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001020 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1021 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 +00001022 return false;
1023#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001024 }
1025#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001026 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001027
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001028 if (Removable)
1029 Update_Size(Display_Error);
1030
1031 if (!Symlink_Mount_Point.empty()) {
codelover2a3d4ce2015-03-14 20:26:49 +08001032 string Command = "mount -o bind '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
Vojtech Bocek05534202013-09-11 08:11:56 +02001033 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001034 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001035 return true;
1036}
1037
1038bool TWPartition::UnMount(bool Display_Error) {
1039 if (Is_Mounted()) {
1040 int never_unmount_system;
1041
1042 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
1043 if (never_unmount_system == 1 && Mount_Point == "/system")
1044 return true; // Never unmount system if you're not supposed to unmount it
1045
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001046 if (Is_Storage)
Ethan Yonker726a0202014-12-16 20:01:38 -06001047 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001048
Dees_Troy38bd7602012-09-14 13:33:53 -04001049 if (!Symlink_Mount_Point.empty())
1050 umount(Symlink_Mount_Point.c_str());
1051
Dees_Troyb05ddee2013-01-28 20:24:50 +00001052 umount(Mount_Point.c_str());
1053 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001054 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +00001055 LOGERR("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001056 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001057 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001058 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001059 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001060 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001061 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001062 } else {
1063 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001064 }
1065}
1066
Gary Peck43acadf2012-11-21 21:19:01 -08001067bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001068 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001069 int check;
1070 string Layout_Filename = Mount_Point + "/.layout_version";
1071
Dees_Troy38bd7602012-09-14 13:33:53 -04001072 if (!Can_Be_Wiped) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001073 LOGERR("Partition '%s' cannot be wiped.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001074 return false;
1075 }
1076
Dees_Troyc51f1f92012-09-20 15:32:13 -04001077 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001078 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001079
Dees_Troy16c2b312013-01-15 16:51:18 +00001080 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
1081 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
1082 else
1083 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -04001084
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001085 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001086 wiped = Wipe_Data_Without_Wiping_Media();
Ethan Yonker5eac2222014-06-11 12:22:55 -05001087 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001088 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001089 DataManager::GetValue(TW_RM_RF_VAR, check);
1090
Hashcodedabfd492013-08-29 22:45:30 -07001091 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001092 wiped = Wipe_RMRF();
1093 else if (New_File_System == "ext4")
1094 wiped = Wipe_EXT4();
1095 else if (New_File_System == "ext2" || New_File_System == "ext3")
1096 wiped = Wipe_EXT23(New_File_System);
1097 else if (New_File_System == "vfat")
1098 wiped = Wipe_FAT();
1099 else if (New_File_System == "exfat")
1100 wiped = Wipe_EXFAT();
1101 else if (New_File_System == "yaffs2")
1102 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001103 else if (New_File_System == "f2fs")
1104 wiped = Wipe_F2FS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001105 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001106 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 +00001107 unlink("/.layout_version");
1108 return false;
1109 }
1110 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001111 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001112
Gary Pecke8bc5d72012-12-21 06:45:25 -08001113 if (wiped) {
Dees_Troy1c1ac442013-01-17 21:42:14 +00001114 if (Mount_Point == "/cache")
1115 DataManager::Output_Version();
1116
Dees_Troy16c2b312013-01-15 16:51:18 +00001117 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
1118 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
1119
1120 if (update_crypt) {
1121 Setup_File_System(false);
1122 if (Is_Encrypted && !Is_Decrypted) {
1123 // just wiped an encrypted partition back to its unencrypted state
1124 Is_Encrypted = false;
1125 Is_Decrypted = false;
1126 Decrypted_Block_Device = "";
1127 if (Mount_Point == "/data") {
1128 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1129 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1130 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001131 }
1132 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001133
1134 if (Mount_Point == "/data" && Has_Data_Media && recreate_media) {
1135 Recreate_Media_Folder();
1136 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001137 }
Ethan Yonker726a0202014-12-16 20:01:38 -06001138 if (Is_Storage) {
1139 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001140 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001141 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001142}
1143
Gary Peck43acadf2012-11-21 21:19:01 -08001144bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001145 if (Is_File_System(Current_File_System))
1146 return Wipe(Current_File_System);
1147 else
1148 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001149}
1150
Dees_Troye58d5262012-09-21 12:27:57 -04001151bool TWPartition::Wipe_AndSec(void) {
1152 if (!Has_Android_Secure)
1153 return false;
1154
Dees_Troye58d5262012-09-21 12:27:57 -04001155 if (!Mount(true))
1156 return false;
1157
Dees_Troy2673cec2013-04-02 20:22:16 +00001158 gui_print("Wiping %s\n", Backup_Display_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001159 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001160 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001161}
1162
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001163bool TWPartition::Can_Repair() {
1164 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/sbin/dosfsck"))
1165 return true;
1166 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/e2fsck"))
1167 return true;
1168 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/fsck.exfat"))
1169 return true;
1170 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/sbin/fsck.f2fs"))
1171 return true;
1172 return false;
1173}
1174
1175bool TWPartition::Repair() {
1176 string command;
1177
1178 if (Current_File_System == "vfat") {
1179 if (!TWFunc::Path_Exists("/sbin/dosfsck")) {
1180 gui_print("dosfsck does not exist! Cannot repair!\n");
1181 return false;
1182 }
1183 if (!UnMount(true))
1184 return false;
1185 gui_print("Repairing %s using dosfsck...\n", Display_Name.c_str());
1186 Find_Actual_Block_Device();
1187 command = "/sbin/dosfsck -y " + Actual_Block_Device;
1188 LOGINFO("Repair command: %s\n", command.c_str());
1189 if (TWFunc::Exec_Cmd(command) == 0) {
1190 gui_print("Done.\n");
1191 return true;
1192 } else {
1193 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1194 return false;
1195 }
1196 }
1197 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1198 if (!TWFunc::Path_Exists("/sbin/e2fsck")) {
1199 gui_print("e2fsck does not exist! Cannot repair!\n");
1200 return false;
1201 }
1202 if (!UnMount(true))
1203 return false;
1204 gui_print("Repairing %s using e2fsck...\n", Display_Name.c_str());
1205 Find_Actual_Block_Device();
1206 command = "/sbin/e2fsck -p " + Actual_Block_Device;
1207 LOGINFO("Repair command: %s\n", command.c_str());
1208 if (TWFunc::Exec_Cmd(command) == 0) {
1209 gui_print("Done.\n");
1210 return true;
1211 } else {
1212 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1213 return false;
1214 }
1215 }
1216 if (Current_File_System == "exfat") {
1217 if (!TWFunc::Path_Exists("/sbin/fsck.exfat")) {
1218 gui_print("fsck.exfat does not exist! Cannot repair!\n");
1219 return false;
1220 }
1221 if (!UnMount(true))
1222 return false;
1223 gui_print("Repairing %s using fsck.exfat...\n", Display_Name.c_str());
1224 Find_Actual_Block_Device();
1225 command = "/sbin/fsck.exfat " + Actual_Block_Device;
1226 LOGINFO("Repair command: %s\n", command.c_str());
1227 if (TWFunc::Exec_Cmd(command) == 0) {
1228 gui_print("Done.\n");
1229 return true;
1230 } else {
1231 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1232 return false;
1233 }
1234 }
1235 if (Current_File_System == "f2fs") {
1236 if (!TWFunc::Path_Exists("/sbin/fsck.f2fs")) {
1237 gui_print("fsck.f2fs does not exist! Cannot repair!\n");
1238 return false;
1239 }
1240 if (!UnMount(true))
1241 return false;
1242 gui_print("Repairing %s using fsck.f2fs...\n", Display_Name.c_str());
1243 Find_Actual_Block_Device();
1244 command = "/sbin/fsck.f2fs " + Actual_Block_Device;
1245 LOGINFO("Repair command: %s\n", command.c_str());
1246 if (TWFunc::Exec_Cmd(command) == 0) {
1247 gui_print("Done.\n");
1248 return true;
1249 } else {
1250 LOGERR("Unable to repair '%s'.\n", Mount_Point.c_str());
1251 return false;
1252 }
1253 }
1254 return false;
1255}
1256
bigbiff7abc5fe2015-01-17 16:53:12 -05001257bool TWPartition::Backup(string backup_folder, const unsigned long long *overall_size, const unsigned long long *other_backups_size, pid_t &tar_fork_pid) {
1258 if (Backup_Method == FILES) {
1259 return Backup_Tar(backup_folder, overall_size, other_backups_size, tar_fork_pid);
1260 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001261 else if (Backup_Method == DD)
1262 return Backup_DD(backup_folder);
1263 else if (Backup_Method == FLASH_UTILS)
1264 return Backup_Dump_Image(backup_folder);
Dees_Troy2673cec2013-04-02 20:22:16 +00001265 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001266 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001267}
1268
Dees_Troy43d8b002012-09-17 16:00:01 -04001269bool TWPartition::Check_MD5(string restore_folder) {
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001270 string Full_Filename, md5file;
Dees_Troy43d8b002012-09-17 16:00:01 -04001271 char split_filename[512];
1272 int index = 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001273 twrpDigest md5sum;
Dees_Troy43d8b002012-09-17 16:00:01 -04001274
Captain Throwbackff5935f2014-09-23 16:08:34 -04001275 sync();
1276
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001277 memset(split_filename, 0, sizeof(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001278 Full_Filename = restore_folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04001279 if (!TWFunc::Path_Exists(Full_Filename)) {
1280 // This is a split archive, we presume
1281 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
Dees_Troy2673cec2013-04-02 20:22:16 +00001282 LOGINFO("split_filename: %s\n", split_filename);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001283 md5file = split_filename;
1284 md5file += ".md5";
1285 if (!TWFunc::Path_Exists(md5file)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001286 LOGERR("No md5 file found for '%s'.\n", split_filename);
1287 LOGERR("Please unselect Enable MD5 verification to restore.\n");
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001288 return false;
1289 }
1290 md5sum.setfn(split_filename);
Dees_Troy83bd4832013-05-04 12:39:56 +00001291 while (index < 1000) {
1292 if (TWFunc::Path_Exists(split_filename) && md5sum.verify_md5digest() != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001293 LOGERR("MD5 failed to match on '%s'.\n", split_filename);
Dees_Troy43d8b002012-09-17 16:00:01 -04001294 return false;
1295 }
1296 index++;
1297 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001298 md5sum.setfn(split_filename);
Dees_Troy43d8b002012-09-17 16:00:01 -04001299 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001300 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001301 } else {
1302 // Single file archive
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001303 md5file = Full_Filename + ".md5";
1304 if (!TWFunc::Path_Exists(md5file)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001305 LOGERR("No md5 file found for '%s'.\n", Full_Filename.c_str());
1306 LOGERR("Please unselect Enable MD5 verification to restore.\n");
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001307 return false;
1308 }
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001309 md5sum.setfn(Full_Filename);
1310 if (md5sum.verify_md5digest() != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001311 LOGERR("MD5 failed to match on '%s'.\n", Full_Filename.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001312 return false;
1313 } else
1314 return true;
1315 }
1316 return false;
1317}
1318
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001319bool TWPartition::Restore(string restore_folder, const unsigned long long *total_restore_size, unsigned long long *already_restored_size) {
Gary Peck43acadf2012-11-21 21:19:01 -08001320 string Restore_File_System;
1321
1322 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
Dees_Troy2673cec2013-04-02 20:22:16 +00001323 LOGINFO("Restore filename is: %s\n", Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001324
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001325 Restore_File_System = Get_Restore_File_System(restore_folder);
1326
1327 if (Is_File_System(Restore_File_System))
1328 return Restore_Tar(restore_folder, Restore_File_System, total_restore_size, already_restored_size);
1329 else if (Is_Image(Restore_File_System)) {
Ethan Yonkerf66324f2015-01-09 16:46:57 -06001330 return Restore_Image(restore_folder, total_restore_size, already_restored_size, Restore_File_System);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001331 }
1332
1333 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1334 return false;
1335}
1336
1337string TWPartition::Get_Restore_File_System(string restore_folder) {
1338 size_t first_period, second_period;
1339 string Restore_File_System;
1340
Gary Peck43acadf2012-11-21 21:19:01 -08001341 // Parse backup filename to extract the file system before wiping
1342 first_period = Backup_FileName.find(".");
1343 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001344 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001345 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001346 }
1347 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
1348 second_period = Restore_File_System.find(".");
1349 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001350 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001351 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001352 }
1353 Restore_File_System.resize(second_period);
Dees_Troy2673cec2013-04-02 20:22:16 +00001354 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001355 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04001356}
1357
1358string TWPartition::Backup_Method_By_Name() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001359 if (Backup_Method == NONE)
1360 return "none";
1361 else if (Backup_Method == FILES)
1362 return "files";
1363 else if (Backup_Method == DD)
1364 return "dd";
1365 else if (Backup_Method == FLASH_UTILS)
1366 return "flash_utils";
1367 else
1368 return "undefined";
1369 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04001370}
1371
1372bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001373 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001374 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04001375 return 1;
1376}
1377
1378bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001379 bool Save_Data_Media = Has_Data_Media;
1380
1381 if (!UnMount(true))
1382 return false;
1383
Dees_Troy38bd7602012-09-14 13:33:53 -04001384 Has_Data_Media = false;
Dees_Troy74fb2e92013-04-15 14:35:47 +00001385 Decrypted_Block_Device = "";
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001386#ifdef TW_INCLUDE_CRYPTO
1387 if (Is_Decrypted) {
1388 if (!UnMount(true))
1389 return false;
Matt Mower2b18a532015-02-20 16:58:05 -06001390 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001391 LOGERR("Error deleting crypto block device, continuing anyway.\n");
1392 }
1393 }
1394#endif
Dees_Troy74fb2e92013-04-15 14:35:47 +00001395 Is_Decrypted = false;
1396 Is_Encrypted = false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001397 Find_Actual_Block_Device();
Gary Pecke8bc5d72012-12-21 06:45:25 -08001398 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001399 Has_Data_Media = Save_Data_Media;
1400 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
1401 Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001402 if (Mount(false))
1403 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001404 }
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001405 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05001406#ifndef TW_OEM_BUILD
Dees_Troy2673cec2013-04-02 20:22:16 +00001407 gui_print("You may need to reboot recovery to be able to use /data again.\n");
Ethan Yonker83e82572014-04-04 10:59:28 -05001408#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001409 return true;
1410 } else {
1411 Has_Data_Media = Save_Data_Media;
Dees_Troy2673cec2013-04-02 20:22:16 +00001412 LOGERR("Unable to format to remove encryption.\n");
Ethan Yonker726a0202014-12-16 20:01:38 -06001413 if (Has_Data_Media && Mount(false))
1414 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001415 return false;
1416 }
1417 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001418}
1419
1420void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001421 const char* type;
1422 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04001423
Dees_Troy68cab492012-12-12 19:29:35 +00001424 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1425 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001426
Dees_Troy38bd7602012-09-14 13:33:53 -04001427 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001428 if (!Is_Present)
1429 return;
Dees_Troy51127312012-09-08 13:08:49 -04001430
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001431 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
1432 if (blkid_do_fullprobe(pr)) {
1433 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001434 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001435 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001436 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001437
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001438 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001439 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001440 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001441 return;
1442 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001443
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001444 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001445 blkid_free_probe(pr);
Dees_Troy51a0e822012-09-05 15:24:24 -04001446}
1447
Gary Peck43acadf2012-11-21 21:19:01 -08001448bool TWPartition::Wipe_EXT23(string File_System) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001449 if (!UnMount(true))
1450 return false;
1451
Dees_Troy43d8b002012-09-17 16:00:01 -04001452 if (TWFunc::Path_Exists("/sbin/mke2fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001453 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001454
Dees_Troy2673cec2013-04-02 20:22:16 +00001455 gui_print("Formatting %s using mke2fs...\n", Display_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001456 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001457 command = "mke2fs -t " + File_System + " -m 0 " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001458 LOGINFO("mke2fs command: %s\n", command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001459 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001460 Current_File_System = File_System;
Dees_Troye58d5262012-09-21 12:27:57 -04001461 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001462 gui_print("Done.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001463 return true;
1464 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001465 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001466 return false;
1467 }
1468 } else
1469 return Wipe_RMRF();
1470
1471 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001472}
1473
1474bool TWPartition::Wipe_EXT4() {
Ethan Yonker25f20c12014-10-14 09:04:43 -05001475 Find_Actual_Block_Device();
1476 if (!Is_Present) {
1477 LOGERR("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
1478 return false;
1479 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001480 if (!UnMount(true))
1481 return false;
1482
Dees_Troyb3265ab2013-08-30 02:59:14 +00001483#if defined(HAVE_SELINUX) && defined(USE_EXT4)
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001484 int ret;
1485 char *secontext = NULL;
1486
Dees_Troya95f55c2013-08-17 13:14:43 +00001487 gui_print("Formatting %s using make_ext4fs function.\n", Display_Name.c_str());
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001488
Dees Troy99c8dbf2014-03-10 16:53:58 +00001489 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001490 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
1491 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), NULL);
1492 } else {
1493 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), selinux_handle);
1494 }
1495 if (ret != 0) {
Dees_Troya95f55c2013-08-17 13:14:43 +00001496 LOGERR("Unable to wipe '%s' using function call.\n", Mount_Point.c_str());
1497 return false;
1498 } else {
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04001499 string sedir = Mount_Point + "/lost+found";
1500 PartitionManager.Mount_By_Path(sedir.c_str(), true);
1501 rmdir(sedir.c_str());
1502 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00001503 return true;
1504 }
1505#else
Dees_Troy43d8b002012-09-17 16:00:01 -04001506 if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001507 string Command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001508
Dees_Troy2673cec2013-04-02 20:22:16 +00001509 gui_print("Formatting %s using make_ext4fs...\n", Display_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001510 Find_Actual_Block_Device();
1511 Command = "make_ext4fs";
1512 if (!Is_Decrypted && Length != 0) {
1513 // Only use length if we're not decrypted
1514 char len[32];
1515 sprintf(len, "%i", Length);
1516 Command += " -l ";
1517 Command += len;
1518 }
Dees_Troy5295d582013-09-06 15:51:08 +00001519 if (TWFunc::Path_Exists("/file_contexts")) {
1520 Command += " -S /file_contexts";
1521 }
1522 Command += " -a " + Mount_Point + " " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001523 LOGINFO("make_ext4fs command: %s\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001524 if (TWFunc::Exec_Cmd(Command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001525 Current_File_System = "ext4";
Dees_Troye58d5262012-09-21 12:27:57 -04001526 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001527 gui_print("Done.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001528 return true;
1529 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001530 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001531 return false;
1532 }
1533 } else
Gary Peck43acadf2012-11-21 21:19:01 -08001534 return Wipe_EXT23("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00001535#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001536 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001537}
1538
1539bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001540 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001541
Dees_Troy43d8b002012-09-17 16:00:01 -04001542 if (TWFunc::Path_Exists("/sbin/mkdosfs")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001543 if (!UnMount(true))
1544 return false;
1545
Dees_Troy2673cec2013-04-02 20:22:16 +00001546 gui_print("Formatting %s using mkdosfs...\n", Display_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001547 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001548 command = "mkdosfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001549 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001550 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04001551 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001552 gui_print("Done.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001553 return true;
1554 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001555 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001556 return false;
1557 }
1558 return true;
1559 }
1560 else
1561 return Wipe_RMRF();
1562
1563 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001564}
1565
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001566bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001567 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001568
1569 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
1570 if (!UnMount(true))
1571 return false;
1572
Dees_Troy2673cec2013-04-02 20:22:16 +00001573 gui_print("Formatting %s using mkexfatfs...\n", Display_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001574 Find_Actual_Block_Device();
1575 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001576 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001577 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001578 gui_print("Done.\n");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001579 return true;
1580 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001581 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001582 return false;
1583 }
1584 return true;
1585 }
1586 return false;
1587}
1588
Dees_Troy38bd7602012-09-14 13:33:53 -04001589bool TWPartition::Wipe_MTD() {
1590 if (!UnMount(true))
1591 return false;
1592
Dees_Troy2673cec2013-04-02 20:22:16 +00001593 gui_print("MTD Formatting \"%s\"\n", MTD_Name.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001594
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001595 mtd_scan_partitions();
1596 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
1597 if (mtd == NULL) {
1598 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
1599 return false;
1600 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001601
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001602 MtdWriteContext* ctx = mtd_write_partition(mtd);
1603 if (ctx == NULL) {
1604 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
1605 return false;
1606 }
1607 if (mtd_erase_blocks(ctx, -1) == -1) {
1608 mtd_write_close(ctx);
1609 LOGERR("Failed to format '%s'", MTD_Name.c_str());
1610 return false;
1611 }
1612 if (mtd_write_close(ctx) != 0) {
1613 LOGERR("Failed to close '%s'", MTD_Name.c_str());
1614 return false;
1615 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001616 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04001617 Recreate_AndSec_Folder();
Dees_Troy2673cec2013-04-02 20:22:16 +00001618 gui_print("Done.\n");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001619 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001620}
1621
1622bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001623 if (!Mount(true))
1624 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06001625 // This is the only wipe that leaves the partition mounted, so we
1626 // must manually remove the partition from MTP if it is a storage
1627 // partition.
1628 if (Is_Storage)
1629 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001630
Dees_Troy2673cec2013-04-02 20:22:16 +00001631 gui_print("Removing all files under '%s'\n", Mount_Point.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001632 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04001633 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001634 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001635}
1636
Dees_Troye5017042013-08-29 16:38:55 +00001637bool TWPartition::Wipe_F2FS() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001638 string command;
Dees_Troye5017042013-08-29 16:38:55 +00001639
1640 if (TWFunc::Path_Exists("/sbin/mkfs.f2fs")) {
1641 if (!UnMount(true))
1642 return false;
1643
1644 gui_print("Formatting %s using mkfs.f2fs...\n", Display_Name.c_str());
1645 Find_Actual_Block_Device();
dhacker29a3fa75f2015-01-17 19:42:33 -05001646 command = "mkfs.f2fs -t 1";
1647 if (!Is_Decrypted && Length != 0) {
1648 // Only use length if we're not decrypted
1649 char len[32];
1650 int mod_length = Length;
1651 if (Length < 0)
1652 mod_length *= -1;
1653 sprintf(len, "%i", mod_length);
1654 command += " -r ";
1655 command += len;
1656 }
1657 command += " " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001658 if (TWFunc::Exec_Cmd(command) == 0) {
Dees_Troye5017042013-08-29 16:38:55 +00001659 Recreate_AndSec_Folder();
1660 gui_print("Done.\n");
1661 return true;
1662 } else {
1663 LOGERR("Unable to wipe '%s'.\n", Mount_Point.c_str());
1664 return false;
1665 }
1666 return true;
1667 } else {
1668 gui_print("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
1669 return Wipe_RMRF();
1670 }
1671 return false;
1672}
1673
Dees_Troy51a0e822012-09-05 15:24:24 -04001674bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05001675#ifdef TW_OEM_BUILD
1676 // In an OEM Build we want to do a full format
1677 return Wipe_Encryption();
1678#else
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001679 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04001680
1681 // This handles wiping data on devices with "sdcard" in /data/media
1682 if (!Mount(true))
1683 return false;
1684
Dees_Troy2673cec2013-04-02 20:22:16 +00001685 gui_print("Wiping data without wiping /data/media ...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001686
1687 DIR* d;
1688 d = opendir("/data");
Dees_Troy16b74352012-11-14 22:27:31 +00001689 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001690 struct dirent* de;
1691 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001692 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
Dees_Troy16b74352012-11-14 22:27:31 +00001693 // The media folder is the "internal sdcard"
1694 // The .layout_version file is responsible for determining whether 4.2 decides up upgrade
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001695 // the media folder for multi-user.
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001696 //TODO: convert this to use twrpDU.cpp
Dees_Troy16b74352012-11-14 22:27:31 +00001697 if (strcmp(de->d_name, "media") == 0 || strcmp(de->d_name, ".layout_version") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001698
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001699 dir = "/data/";
1700 dir.append(de->d_name);
Dees_Troyce675462013-01-09 19:48:21 +00001701 if (de->d_type == DT_DIR) {
1702 TWFunc::removeDir(dir, false);
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05001703 } 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 +00001704 if (!unlink(dir.c_str()))
Dees_Troy2673cec2013-04-02 20:22:16 +00001705 LOGINFO("Unable to unlink '%s'\n", dir.c_str());
Dees_Troyce675462013-01-09 19:48:21 +00001706 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001707 }
1708 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001709
Dees_Troy2673cec2013-04-02 20:22:16 +00001710 gui_print("Done.\n");
Dees_Troy16b74352012-11-14 22:27:31 +00001711 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001712 }
Dees_Troy2673cec2013-04-02 20:22:16 +00001713 gui_print("Dirent failed to open /data, error!\n");
Dees_Troy16b74352012-11-14 22:27:31 +00001714 return false;
Ethan Yonker83e82572014-04-04 10:59:28 -05001715#endif // ifdef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -04001716}
1717
bigbiff7abc5fe2015-01-17 16:53:12 -05001718bool TWPartition::Backup_Tar(string backup_folder, const unsigned long long *overall_size, const unsigned long long *other_backups_size, pid_t &tar_fork_pid) {
Dees_Troy4a2a1262012-09-18 09:33:47 -04001719 char back_name[255], split_index[5];
1720 string Full_FileName, Split_FileName, Tar_Args, Command;
Dees_Troy83bd4832013-05-04 12:39:56 +00001721 int use_compression, use_encryption = 0, index, backup_count;
Dees_Troy4a2a1262012-09-18 09:33:47 -04001722 struct stat st;
Dees_Troy7c2dec82012-09-26 09:49:14 -04001723 unsigned long long total_bsize = 0, file_size;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001724 twrpTar tar;
1725 vector <string> files;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001726
Dees_Troy43d8b002012-09-17 16:00:01 -04001727 if (!Mount(true))
1728 return false;
1729
Dees_Troya13d74f2013-03-24 08:54:55 -05001730 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, "Backing Up");
Dees_Troy2673cec2013-04-02 20:22:16 +00001731 gui_print("Backing up %s...\n", Backup_Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001732
1733 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy83bd4832013-05-04 12:39:56 +00001734 tar.use_compression = use_compression;
Matt Mowerbb81e5d2014-03-20 18:05:41 -05001735
Dees_Troy83bd4832013-05-04 12:39:56 +00001736#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
1737 DataManager::GetValue("tw_encrypt_backup", use_encryption);
1738 if (use_encryption && Can_Encrypt_Backup) {
1739 tar.use_encryption = use_encryption;
1740 if (Use_Userdata_Encryption)
1741 tar.userdata_encryption = use_encryption;
Ethan Yonker87af5632014-02-10 11:56:35 -06001742 string Password;
1743 DataManager::GetValue("tw_backup_password", Password);
1744 tar.setpassword(Password);
Dees_Troy83bd4832013-05-04 12:39:56 +00001745 } else {
1746 use_encryption = false;
1747 }
1748#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04001749
1750 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1751 Backup_FileName = back_name;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001752 Full_FileName = backup_folder + "/" + Backup_FileName;
Dees_Troy83bd4832013-05-04 12:39:56 +00001753 tar.has_data_media = Has_Data_Media;
Dees Troye0a433a2013-12-02 04:10:37 +00001754 Full_FileName = backup_folder + "/" + Backup_FileName;
1755 tar.setdir(Backup_Path);
1756 tar.setfn(Full_FileName);
1757 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001758 tar.partition_name = Backup_Name;
1759 tar.backup_folder = backup_folder;
bigbiff7abc5fe2015-01-17 16:53:12 -05001760 if (tar.createTarFork(overall_size, other_backups_size, tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00001761 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04001762 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001763}
1764
1765bool TWPartition::Backup_DD(string backup_folder) {
igoriok87e3d932013-01-31 21:03:53 +02001766 char back_name[255], backup_size[32];
Vojtech Bocek05534202013-09-11 08:11:56 +02001767 string Full_FileName, Command, DD_BS;
Dees_Troy43d8b002012-09-17 16:00:01 -04001768 int use_compression;
1769
igoriok87e3d932013-01-31 21:03:53 +02001770 sprintf(backup_size, "%llu", Backup_Size);
1771 DD_BS = backup_size;
1772
Dees_Troyb46a6842012-09-25 11:06:46 -04001773 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
Dees_Troy2673cec2013-04-02 20:22:16 +00001774 gui_print("Backing up %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001775
1776 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1777 Backup_FileName = back_name;
1778
1779 Full_FileName = backup_folder + "/" + Backup_FileName;
1780
Ethan Yonker448c8dc2014-12-08 15:34:34 -06001781 Command = "dd if=" + Actual_Block_Device + " of='" + Full_FileName + "'" + " bs=" + DD_BS + " count=1";
Dees_Troy2673cec2013-04-02 20:22:16 +00001782 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001783 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06001784 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troyc154ac22012-10-12 15:36:47 -04001785 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001786 LOGERR("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04001787 return false;
1788 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001789 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001790}
1791
1792bool TWPartition::Backup_Dump_Image(string backup_folder) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001793 char back_name[255];
Vojtech Bocek05534202013-09-11 08:11:56 +02001794 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04001795 int use_compression;
1796
Dees_Troyb46a6842012-09-25 11:06:46 -04001797 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
Dees_Troy2673cec2013-04-02 20:22:16 +00001798 gui_print("Backing up %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001799
1800 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1801 Backup_FileName = back_name;
1802
1803 Full_FileName = backup_folder + "/" + Backup_FileName;
1804
1805 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
Dees_Troy2673cec2013-04-02 20:22:16 +00001806 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001807 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06001808 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04001809 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
1810 // 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 +00001811 LOGERR("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04001812 return false;
1813 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001814 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001815}
1816
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001817unsigned long long TWPartition::Get_Restore_Size(string restore_folder) {
1818 InfoManager restore_info(restore_folder + "/" + Backup_Name + ".info");
1819 if (restore_info.LoadValues() == 0) {
1820 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
1821 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
1822 return Restore_Size;
1823 }
1824 }
1825 string Full_FileName, Restore_File_System = Get_Restore_File_System(restore_folder);
1826
1827 Full_FileName = restore_folder + "/" + Backup_FileName;
1828
1829 if (Is_Image(Restore_File_System)) {
1830 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
1831 return Restore_Size;
1832 }
1833
1834 twrpTar tar;
1835 tar.setdir(Backup_Path);
1836 tar.setfn(Full_FileName);
1837 tar.backup_name = Backup_Name;
1838#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
1839 string Password;
1840 DataManager::GetValue("tw_restore_password", Password);
1841 if (!Password.empty())
1842 tar.setpassword(Password);
1843#endif
1844 tar.partition_name = Backup_Name;
1845 tar.backup_folder = restore_folder;
1846 Restore_Size = tar.get_size();
1847 return Restore_Size;
1848}
1849
1850bool TWPartition::Restore_Tar(string restore_folder, string Restore_File_System, const unsigned long long *total_restore_size, unsigned long long *already_restored_size) {
Gary Peck43acadf2012-11-21 21:19:01 -08001851 string Full_FileName, Command;
Dees_Troy4a2a1262012-09-18 09:33:47 -04001852 int index = 0;
1853 char split_index[5];
Dees Troy4159aed2014-02-28 17:24:43 +00001854 bool ret = false;
Dees_Troy43d8b002012-09-17 16:00:01 -04001855
Dees_Troye58d5262012-09-21 12:27:57 -04001856 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04001857 if (!Wipe_AndSec())
1858 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08001859 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001860 gui_print("Wiping %s...\n", Display_Name.c_str());
Ethan Yonker5eac2222014-06-11 12:22:55 -05001861 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
1862 gui_print("WARNING: This /data backup was made with %s file system!\n", Restore_File_System.c_str());
1863 gui_print("The backup may not boot unless you change back to %s.\n", Restore_File_System.c_str());
1864 if (!Wipe_Data_Without_Wiping_Media())
1865 return false;
1866 } else {
1867 if (!Wipe(Restore_File_System))
1868 return false;
1869 }
Dees_Troye58d5262012-09-21 12:27:57 -04001870 }
Dees_Troya13d74f2013-03-24 08:54:55 -05001871 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, "Restoring");
Dees_Troy2673cec2013-04-02 20:22:16 +00001872 gui_print("Restoring %s...\n", Backup_Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001873
1874 if (!Mount(true))
1875 return false;
1876
Dees_Troy4a2a1262012-09-18 09:33:47 -04001877 Full_FileName = restore_folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06001878 twrpTar tar;
1879 tar.setdir(Backup_Path);
1880 tar.setfn(Full_FileName);
1881 tar.backup_name = Backup_Name;
1882#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
1883 string Password;
1884 DataManager::GetValue("tw_restore_password", Password);
1885 if (!Password.empty())
1886 tar.setpassword(Password);
1887#endif
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001888 if (tar.extractTarFork(total_restore_size, already_restored_size) != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00001889 ret = false;
1890 else
1891 ret = true;
1892#ifdef HAVE_CAPABILITIES
1893 // Restore capabilities to the run-as binary
1894 if (Mount_Point == "/system" && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
1895 struct vfs_cap_data cap_data;
1896 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
1897
1898 memset(&cap_data, 0, sizeof(cap_data));
1899 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
1900 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
1901 cap_data.data[0].inheritable = 0;
1902 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
1903 cap_data.data[1].inheritable = 0;
1904 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
1905 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
1906 } else {
1907 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
1908 }
1909 }
1910#endif
1911 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04001912}
1913
Ethan Yonker96af84a2015-01-05 14:58:36 -06001914bool TWPartition::Restore_Image(string restore_folder, const unsigned long long *total_restore_size, unsigned long long *already_restored_size, string Restore_File_System) {
1915 string Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001916 double display_percent, progress_percent;
1917 char size_progress[1024];
Dees_Troy43d8b002012-09-17 16:00:01 -04001918
Dees_Troyda8b55a2012-12-12 19:18:30 +00001919 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
Dees_Troy43d8b002012-09-17 16:00:01 -04001920 Full_FileName = restore_folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08001921
Ethan Yonker96af84a2015-01-05 14:58:36 -06001922 if (Restore_File_System == "emmc") {
1923 if (!Flash_Image_DD(Full_FileName))
1924 return false;
1925 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
1926 if (!Flash_Image_FI(Full_FileName))
1927 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08001928 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001929 display_percent = (double)(Restore_Size + *already_restored_size) / (double)(*total_restore_size) * 100;
1930 sprintf(size_progress, "%lluMB of %lluMB, %i%%", (Restore_Size + *already_restored_size) / 1048576, *total_restore_size / 1048576, (int)(display_percent));
1931 DataManager::SetValue("tw_size_progress", size_progress);
1932 progress_percent = (display_percent / 100);
1933 DataManager::SetProgress((float)(progress_percent));
1934 *already_restored_size += Restore_Size;
Dees_Troy43d8b002012-09-17 16:00:01 -04001935 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001936}
Dees_Troy5bf43922012-09-07 16:07:55 -04001937
1938bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04001939 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04001940
Dees_Troyab10ee22012-09-21 14:27:30 -04001941 if (!Can_Be_Mounted && !Is_Encrypted)
Dees_Troy5bf43922012-09-07 16:07:55 -04001942 return false;
1943
Dees_Troy0550cfb2012-10-13 11:56:13 -04001944 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04001945 if (Removable || Is_Encrypted) {
1946 if (!Mount(false))
1947 return true;
1948 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04001949 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001950
1951 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001952 if (!ret || Size == 0) {
1953 if (!Get_Size_Via_df(Display_Error)) {
1954 if (!Was_Already_Mounted)
1955 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04001956 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001957 }
1958 }
Dees_Troy51127312012-09-08 13:08:49 -04001959
Dees_Troy5bf43922012-09-07 16:07:55 -04001960 if (Has_Data_Media) {
1961 if (Mount(Display_Error)) {
Dees_Troy51127312012-09-08 13:08:49 -04001962 unsigned long long data_media_used, actual_data;
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001963 Used = du.Get_Folder_Size("/data");
1964 Backup_Size = Used;
1965 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04001966 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001967 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001968 } else {
1969 if (!Was_Already_Mounted)
1970 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04001971 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001972 }
Dees_Troye58d5262012-09-21 12:27:57 -04001973 } else if (Has_Android_Secure) {
1974 if (Mount(Display_Error))
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001975 Backup_Size = du.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001976 else {
1977 if (!Was_Already_Mounted)
1978 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04001979 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001980 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001981 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04001982 if (!Was_Already_Mounted)
1983 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04001984 return true;
Dees_Troy51127312012-09-08 13:08:49 -04001985}
Dees_Troy38bd7602012-09-14 13:33:53 -04001986
1987void TWPartition::Find_Actual_Block_Device(void) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001988 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001989 Actual_Block_Device = Decrypted_Block_Device;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001990 if (TWFunc::Path_Exists(Decrypted_Block_Device))
Dees_Troy38bd7602012-09-14 13:33:53 -04001991 Is_Present = true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001992 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001993 Is_Present = true;
1994 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001995 return;
1996 }
1997 if (Is_Decrypted) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001998 } else if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04001999 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04002000 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002001 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04002002 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002003 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002004}
2005
2006void TWPartition::Recreate_Media_Folder(void) {
2007 string Command;
2008
2009 if (!Mount(true)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002010 LOGERR("Unable to recreate /data/media folder.\n");
Dees_Troyb46a6842012-09-25 11:06:46 -04002011 } else if (!TWFunc::Path_Exists("/data/media")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002012 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy2673cec2013-04-02 20:22:16 +00002013 LOGINFO("Recreating /data/media folder.\n");
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002014 mkdir("/data/media", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
Ethan Yonker5ef301e2014-10-14 10:04:44 -05002015#ifdef HAVE_SELINUX
thata3d31fb2014-12-21 22:27:40 +01002016 // Attempt to set the correct SELinux contexts on the folder
2017 fixPermissions perms;
bigbiff bigbiff6b600f92014-01-05 18:13:43 -05002018 perms.fixDataInternalContexts();
thata3d31fb2014-12-21 22:27:40 +01002019 // Afterwards, we will try to set the
2020 // default metadata that we were hopefully able to get during
2021 // early boot.
2022 tw_set_default_metadata("/data/media");
Ethan Yonker5ef301e2014-10-14 10:04:44 -05002023#endif
Ethan Yonker5eac2222014-06-11 12:22:55 -05002024 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002025 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05002026 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04002027 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002028}
Dees_Troye58d5262012-09-21 12:27:57 -04002029
2030void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04002031 if (!Has_Android_Secure)
2032 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00002033 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002034 if (!Mount(true)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002035 LOGERR("Unable to recreate %s folder.\n", Backup_Name.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002036 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002037 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002038 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002039 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002040 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002041 }
2042}
bigbiff7cb4c332014-11-26 20:36:07 -05002043
2044uint64_t TWPartition::Get_Max_FileSize() {
2045 uint64_t maxFileSize = 0;
2046 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
2047 const uint64_t constTB = (uint64_t) constGB * 1024;
2048 const uint64_t constPB = (uint64_t) constTB * 1024;
2049 const uint64_t constEB = (uint64_t) constPB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05002050 if (Current_File_System == "ext4")
2051 maxFileSize = 16 * constTB; //16 TB
2052 else if (Current_File_System == "vfat")
2053 maxFileSize = 4 * constGB; //4 GB
2054 else if (Current_File_System == "ntfs")
2055 maxFileSize = 256 * constTB; //256 TB
2056 else if (Current_File_System == "exfat")
2057 maxFileSize = 16 * constPB; //16 PB
2058 else if (Current_File_System == "ext3")
2059 maxFileSize = 2 * constTB; //2 TB
2060 else if (Current_File_System == "f2fs")
2061 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05002062 else
2063 maxFileSize = 100000000L;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002064 LOGINFO("Get_Max_FileSize::maxFileSize: %llu\n", maxFileSize);
bigbiff7cb4c332014-11-26 20:36:07 -05002065 return maxFileSize - 1;
2066}
2067
Ethan Yonker96af84a2015-01-05 14:58:36 -06002068bool TWPartition::Flash_Image(string Filename) {
2069 string Restore_File_System;
2070
2071 LOGINFO("Image filename is: %s\n", Filename.c_str());
2072
2073 if (Backup_Method == FILES) {
2074 LOGERR("Cannot flash images to file systems\n");
2075 return false;
2076 } else if (!Can_Flash_Img) {
2077 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
2078 return false;
2079 } else {
2080 if (!Find_Partition_Size()) {
2081 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
2082 return false;
2083 }
2084 unsigned long long image_size = TWFunc::Get_File_Size(Filename);
2085 if (image_size > Size) {
2086 LOGERR("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
2087 image_size, Filename.c_str(), Actual_Block_Device.c_str(), Size);
2088 return false;
2089 }
2090 if (Backup_Method == DD)
2091 return Flash_Image_DD(Filename);
2092 else if (Backup_Method == FLASH_UTILS)
2093 return Flash_Image_FI(Filename);
2094 }
2095
2096 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
2097 return false;
2098}
2099
2100bool TWPartition::Flash_Image_DD(string Filename) {
2101 string Command;
2102
2103 gui_print("Flashing %s...\n", Display_Name.c_str());
2104 Command = "dd bs=4096 if='" + Filename + "' of=" + Actual_Block_Device;
2105 LOGINFO("Flash command: '%s'\n", Command.c_str());
2106 TWFunc::Exec_Cmd(Command);
2107 return true;
2108}
2109
2110bool TWPartition::Flash_Image_FI(string Filename) {
2111 string Command;
2112
2113 gui_print("Flashing %s...\n", Display_Name.c_str());
2114 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
2115 Command = "erase_image " + MTD_Name;
2116 LOGINFO("Erase command: '%s'\n", Command.c_str());
2117 TWFunc::Exec_Cmd(Command);
2118 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
2119 LOGINFO("Flash command: '%s'\n", Command.c_str());
2120 TWFunc::Exec_Cmd(Command);
2121 return true;
2122}