blob: 2f37d6f895b410eeab49c55b393532925efcc35a [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"
Ethan Yonker74db1572015-10-28 12:44:49 -050046#include "gui/gui.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040047extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040048 #include "mtdutils/mtdutils.h"
49 #include "mtdutils/mounts.h"
Dees_Troya95f55c2013-08-17 13:14:43 +000050#ifdef USE_EXT4
51 #include "make_ext4fs.h"
52#endif
Ethan Yonker71413f42014-02-26 13:36:08 -060053
54#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker253368a2014-11-25 15:00:52 -060055 #include "crypto/lollipop/cryptfs.h"
Ethan Yonkerbc85b632015-08-09 12:48:14 -050056#else
57 #define CRYPT_FOOTER_OFFSET 0x4000
Ethan Yonker71413f42014-02-26 13:36:08 -060058#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040059}
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040060#ifdef HAVE_SELINUX
61#include "selinux/selinux.h"
Ethan Yonkerf27497f2014-02-09 11:48:33 -060062#include <selinux/label.h>
bigbiff bigbiffc49d7062013-10-11 20:28:00 -040063#endif
Dees Troy4159aed2014-02-28 17:24:43 +000064#ifdef HAVE_CAPABILITIES
65#include <sys/capability.h>
66#include <sys/xattr.h>
67#include <linux/xattr.h>
68#endif
Dees_Troy51a0e822012-09-05 15:24:24 -040069
bigbiff bigbiff9c754052013-01-09 09:09:08 -050070using namespace std;
71
Dees_Troya95f55c2013-08-17 13:14:43 +000072extern struct selabel_handle *selinux_handle;
Ethan Yonker6277c792014-09-15 14:54:30 -050073extern bool datamedia;
Dees_Troya95f55c2013-08-17 13:14:43 +000074
Hashcode62bd9e02013-11-19 21:59:42 -080075struct flag_list {
76 const char *name;
77 unsigned flag;
78};
79
80static struct flag_list mount_flags[] = {
81 { "noatime", MS_NOATIME },
82 { "noexec", MS_NOEXEC },
83 { "nosuid", MS_NOSUID },
84 { "nodev", MS_NODEV },
85 { "nodiratime", MS_NODIRATIME },
86 { "ro", MS_RDONLY },
87 { "rw", 0 },
88 { "remount", MS_REMOUNT },
89 { "bind", MS_BIND },
90 { "rec", MS_REC },
Dees Troyc4bc30e2014-02-03 15:04:19 +000091#ifdef MS_UNBINDABLE
Hashcode62bd9e02013-11-19 21:59:42 -080092 { "unbindable", MS_UNBINDABLE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000093#endif
94#ifdef MS_PRIVATE
Hashcode62bd9e02013-11-19 21:59:42 -080095 { "private", MS_PRIVATE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000096#endif
97#ifdef MS_SLAVE
Hashcode62bd9e02013-11-19 21:59:42 -080098 { "slave", MS_SLAVE },
Dees Troyc4bc30e2014-02-03 15:04:19 +000099#endif
100#ifdef MS_SHARED
Hashcode62bd9e02013-11-19 21:59:42 -0800101 { "shared", MS_SHARED },
Dees Troyc4bc30e2014-02-03 15:04:19 +0000102#endif
Hashcode62bd9e02013-11-19 21:59:42 -0800103 { "sync", MS_SYNCHRONOUS },
104 { "defaults", 0 },
105 { 0, 0 },
106};
107
that9e0593e2014-10-08 00:01:24 +0200108TWPartition::TWPartition() {
Dees_Troy51a0e822012-09-05 15:24:24 -0400109 Can_Be_Mounted = false;
110 Can_Be_Wiped = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500111 Can_Be_Backed_Up = false;
Vojtech Bocek1dc30982013-08-30 21:49:30 +0200112 Use_Rm_Rf = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400113 Wipe_During_Factory_Reset = false;
114 Wipe_Available_in_GUI = false;
115 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -0400116 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400117 SubPartition_Of = "";
118 Symlink_Path = "";
119 Symlink_Mount_Point = "";
120 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -0400121 Backup_Path = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400122 Actual_Block_Device = "";
123 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400124 Alternate_Block_Device = "";
125 Removable = false;
126 Is_Present = false;
127 Length = 0;
128 Size = 0;
129 Used = 0;
130 Free = 0;
131 Backup_Size = 0;
132 Can_Be_Encrypted = false;
133 Is_Encrypted = false;
134 Is_Decrypted = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600135 Mount_To_Decrypt = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400136 Decrypted_Block_Device = "";
137 Display_Name = "";
Dees_Troya13d74f2013-03-24 08:54:55 -0500138 Backup_Display_Name = "";
139 Storage_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400140 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -0400141 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -0400142 MTD_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400143 Backup_Method = NONE;
Dees_Troy83bd4832013-05-04 12:39:56 +0000144 Can_Encrypt_Backup = false;
145 Use_Userdata_Encryption = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400146 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -0400147 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400148 Is_Storage = false;
Dees_Troya13d74f2013-03-24 08:54:55 -0500149 Is_Settings_Storage = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400150 Storage_Path = "";
151 Current_File_System = "";
152 Fstab_File_System = "";
Hashcode62bd9e02013-11-19 21:59:42 -0800153 Mount_Flags = 0;
154 Mount_Options = "";
Dees_Troy51a0e822012-09-05 15:24:24 -0400155 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +0000156 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +0000157 Retain_Layout_Version = false;
Ethan Yonker253368a2014-11-25 15:00:52 -0600158 Crypto_Key_Location = "footer";
Ethan Yonker726a0202014-12-16 20:01:38 -0600159 MTP_Storage_ID = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600160 Can_Flash_Img = false;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500161 Mount_Read_Only = false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400162}
163
164TWPartition::~TWPartition(void) {
165 // Do nothing
166}
167
Dees_Troy5bf43922012-09-07 16:07:55 -0400168bool TWPartition::Process_Fstab_Line(string Line, bool Display_Error) {
169 char full_line[MAX_FSTAB_LINE_LENGTH], item[MAX_FSTAB_LINE_LENGTH];
170 int line_len = Line.size(), index = 0, item_index = 0;
171 char* ptr;
Dees_Troy51127312012-09-08 13:08:49 -0400172 string Flags;
Dees_Troy5bf43922012-09-07 16:07:55 -0400173 strncpy(full_line, Line.c_str(), line_len);
Dees_Troya13d74f2013-03-24 08:54:55 -0500174 bool skip = false;
Dees_Troy5bf43922012-09-07 16:07:55 -0400175
Dees_Troy51127312012-09-08 13:08:49 -0400176 for (index = 0; index < line_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500177 if (full_line[index] == 34)
178 skip = !skip;
179 if (!skip && full_line[index] <= 32)
Dees_Troy5bf43922012-09-07 16:07:55 -0400180 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400181 }
Dees_Troy7c2dec82012-09-26 09:49:14 -0400182 Mount_Point = full_line;
Dees_Troy2673cec2013-04-02 20:22:16 +0000183 LOGINFO("Processing '%s'\n", Mount_Point.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -0400184 Backup_Path = Mount_Point;
Dees_Troya13d74f2013-03-24 08:54:55 -0500185 Storage_Path = Mount_Point;
Dees_Troy70737fa2013-04-08 13:19:20 +0000186 Display_Name = full_line + 1;
187 Backup_Display_Name = Display_Name;
188 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400189 index = Mount_Point.size();
190 while (index < line_len) {
191 while (index < line_len && full_line[index] == '\0')
192 index++;
193 if (index >= line_len)
194 continue;
195 ptr = full_line + index;
196 if (item_index == 0) {
197 // File System
198 Fstab_File_System = ptr;
199 Current_File_System = ptr;
200 item_index++;
201 } else if (item_index == 1) {
202 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400203 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400204 MTD_Name = ptr;
205 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400206 } else if (Fstab_File_System == "bml") {
207 if (Mount_Point == "/boot")
208 MTD_Name = "boot";
209 else if (Mount_Point == "/recovery")
210 MTD_Name = "recovery";
211 Primary_Block_Device = ptr;
212 if (*ptr != '/')
Dees_Troy2673cec2013-04-02 20:22:16 +0000213 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 -0400214 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400215 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000216 LOGERR("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
Dees_Troy5bf43922012-09-07 16:07:55 -0400217 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000218 LOGINFO("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
Dees_Troy5bf43922012-09-07 16:07:55 -0400219 return 0;
Dees_Troy38bd7602012-09-14 13:33:53 -0400220 } else {
221 Primary_Block_Device = ptr;
222 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400223 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400224 item_index++;
225 } else if (item_index > 1) {
226 if (*ptr == '/') {
227 // Alternate Block Device
228 Alternate_Block_Device = ptr;
229 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
230 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
231 // Partition length
232 ptr += 7;
233 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400234 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
235 // Custom flags, save for later so that new values aren't overwritten by defaults
236 ptr += 6;
237 Flags = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000238 Process_Flags(Flags, Display_Error);
Dees_Troy38bd7602012-09-14 13:33:53 -0400239 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
240 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400241 } else {
242 // Unhandled data
Dees_Troy2673cec2013-04-02 20:22:16 +0000243 LOGINFO("Unhandled fstab information: '%s', %i, line: '%s'\n", ptr, index, Line.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400244 }
245 }
246 while (index < line_len && full_line[index] != '\0')
247 index++;
248 }
249
250 if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
251 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000252 LOGERR("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400253 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000254 LOGINFO("Unknown File System: '%s'\n", Fstab_File_System.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400255 return 0;
256 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400257 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400258 Setup_File_System(Display_Error);
259 if (Mount_Point == "/system") {
260 Display_Name = "System";
Dees_Troya13d74f2013-03-24 08:54:55 -0500261 Backup_Display_Name = Display_Name;
262 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400263 Wipe_Available_in_GUI = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500264 Can_Be_Backed_Up = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500265 Mount_Read_Only = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400266 } else if (Mount_Point == "/data") {
Dees Troyc657cc02015-01-16 22:48:47 +0000267 UnMount(false); // added in case /data is mounted as tmpfs for qcom hardware decrypt
Dees_Troy5bf43922012-09-07 16:07:55 -0400268 Display_Name = "Data";
Dees_Troya13d74f2013-03-24 08:54:55 -0500269 Backup_Display_Name = Display_Name;
270 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400271 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400272 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500273 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000274 Can_Encrypt_Backup = true;
275 Use_Userdata_Encryption = true;
Ethan Yonker6277c792014-09-15 14:54:30 -0500276 if (datamedia)
that9e0593e2014-10-08 00:01:24 +0200277 Setup_Data_Media();
Dees_Troy5bf43922012-09-07 16:07:55 -0400278#ifdef TW_INCLUDE_CRYPTO
279 Can_Be_Encrypted = true;
Dees_Troy657c3092012-09-10 20:32:10 -0400280 char crypto_blkdev[255];
281 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
282 if (strcmp(crypto_blkdev, "error") != 0) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400283 DataManager::SetValue(TW_DATA_BLK_DEVICE, Primary_Block_Device);
Dees_Troy657c3092012-09-10 20:32:10 -0400284 DataManager::SetValue(TW_IS_DECRYPTED, 1);
285 Is_Encrypted = true;
286 Is_Decrypted = true;
287 Decrypted_Block_Device = crypto_blkdev;
Dees_Troy2673cec2013-04-02 20:22:16 +0000288 LOGINFO("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
Dees_Troy657c3092012-09-10 20:32:10 -0400289 } else if (!Mount(false)) {
Ethan Yonker71413f42014-02-26 13:36:08 -0600290 if (Is_Present) {
Ethan Yonker253368a2014-11-25 15:00:52 -0600291 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 -0600292 if (cryptfs_check_footer() == 0) {
293 Is_Encrypted = true;
294 Is_Decrypted = false;
295 Can_Be_Mounted = false;
296 Current_File_System = "emmc";
297 Setup_Image(Display_Error);
298 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
Vojtech Bocek7e11ac52015-03-05 23:21:49 +0100299 DataManager::SetValue(TW_CRYPTO_PWTYPE, cryptfs_get_password_type());
Ethan Yonker71413f42014-02-26 13:36:08 -0600300 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
301 DataManager::SetValue("tw_crypto_display", "");
302 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500303 gui_err("mount_data_footer=Could not mount /data and unable to find crypto footer.");
Ethan Yonker71413f42014-02-26 13:36:08 -0600304 }
305 } else {
306 LOGERR("Primary block device '%s' for mount point '%s' is not present!\n", Primary_Block_Device.c_str(), Mount_Point.c_str());
307 }
Gary Peck82599a82012-11-21 16:23:12 -0800308 } else {
309 // Filesystem is not encrypted and the mount
310 // succeeded, so get it back to the original
311 // unmounted state
312 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -0400313 }
Ethan Yonker6277c792014-09-15 14:54:30 -0500314 if (datamedia && (!Is_Encrypted || (Is_Encrypted && Is_Decrypted)))
Dees_Troy9b21af72012-10-01 15:51:46 -0400315 Recreate_Media_Folder();
Dees_Troy9b21af72012-10-01 15:51:46 -0400316#else
Ethan Yonker6277c792014-09-15 14:54:30 -0500317 if (datamedia)
318 Recreate_Media_Folder();
Dees_Troy5bf43922012-09-07 16:07:55 -0400319#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400320 } else if (Mount_Point == "/cache") {
321 Display_Name = "Cache";
Dees_Troya13d74f2013-03-24 08:54:55 -0500322 Backup_Display_Name = Display_Name;
323 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400324 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400325 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500326 Can_Be_Backed_Up = true;
Dees_Troyce2fe772012-09-28 12:34:33 -0400327 if (Mount(false) && !TWFunc::Path_Exists("/cache/recovery/.")) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000328 LOGINFO("Recreating /cache/recovery folder.\n");
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500329 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500330 return -1;
Dees_Troyb46a6842012-09-25 11:06:46 -0400331 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400332 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400333 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400334 Display_Name = "DataData";
Dees_Troya13d74f2013-03-24 08:54:55 -0500335 Backup_Display_Name = Display_Name;
336 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400337 Is_SubPartition = true;
338 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400339 DataManager::SetValue(TW_HAS_DATADATA, 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500340 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000341 Can_Encrypt_Backup = true;
342 Use_Userdata_Encryption = false; // This whole partition should be encrypted
Dees_Troy5bf43922012-09-07 16:07:55 -0400343 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400344 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400345 Display_Name = "SD-Ext";
Dees_Troya13d74f2013-03-24 08:54:55 -0500346 Backup_Display_Name = Display_Name;
347 Storage_Name = Display_Name;
Dees_Troy5bf43922012-09-07 16:07:55 -0400348 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400349 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500350 Can_Be_Backed_Up = true;
Dees_Troy83bd4832013-05-04 12:39:56 +0000351 Can_Encrypt_Backup = true;
352 Use_Userdata_Encryption = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400353 } else if (Mount_Point == "/boot") {
354 Display_Name = "Boot";
Dees_Troya13d74f2013-03-24 08:54:55 -0500355 Backup_Display_Name = Display_Name;
Dees_Troy2c50e182012-09-26 20:05:28 -0400356 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troya13d74f2013-03-24 08:54:55 -0500357 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500358 } else if (Mount_Point == "/vendor") {
359 Display_Name = "Vendor";
360 Backup_Display_Name = Display_Name;
361 Storage_Name = Display_Name;
362 Mount_Read_Only = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400363 }
364#ifdef TW_EXTERNAL_STORAGE_PATH
365 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
366 Is_Storage = true;
367 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400368 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500369 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400370#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000371 if (Mount_Point == "/sdcard" || Mount_Point == "/external_sd" || Mount_Point == "/external_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400372 Is_Storage = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400373 Removable = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500374 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400375#endif
Dees_Troyb05ddee2013-01-28 20:24:50 +0000376 }
Dees_Troy8170a922012-09-18 15:40:25 -0400377#ifdef TW_INTERNAL_STORAGE_PATH
378 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
379 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500380 Is_Settings_Storage = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400381 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troya13d74f2013-03-24 08:54:55 -0500382 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400383 }
384#else
Dees_Troy70737fa2013-04-08 13:19:20 +0000385 if (Mount_Point == "/emmc" || Mount_Point == "/internal_sd" || Mount_Point == "/internal_sdcard") {
Dees_Troy8170a922012-09-18 15:40:25 -0400386 Is_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500387 Is_Settings_Storage = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500388 Wipe_Available_in_GUI = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400389 }
390#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400391 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400392 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400393 Setup_Image(Display_Error);
Dees_Troya13d74f2013-03-24 08:54:55 -0500394 if (Mount_Point == "/boot") {
395 Display_Name = "Boot";
396 Backup_Display_Name = Display_Name;
397 Can_Be_Backed_Up = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600398 Can_Flash_Img = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500399 } else if (Mount_Point == "/recovery") {
400 Display_Name = "Recovery";
401 Backup_Display_Name = Display_Name;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600402 Can_Flash_Img = true;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500403 } else if (Mount_Point == "/system_image") {
404 Display_Name = "System Image";
405 Backup_Display_Name = Display_Name;
406 Can_Flash_Img = false;
407 Can_Be_Backed_Up = true;
Ethan Yonker1673e3d2015-10-26 21:51:58 -0500408 } else if (Mount_Point == "/vendor_image") {
409 Display_Name = "Vendor Image";
410 Backup_Display_Name = Display_Name;
411 Can_Flash_Img = false;
412 Can_Be_Backed_Up = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500413 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400414 }
415
Dees_Troy51127312012-09-08 13:08:49 -0400416 // Process any custom flags
417 if (Flags.size() > 0)
418 Process_Flags(Flags, Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -0400419 return true;
420}
421
Ketut Putu Kumajayabfb72b02015-08-10 16:40:55 +0200422bool TWPartition::Process_FS_Flags(string& Options, int& Flags) {
Hashcode62bd9e02013-11-19 21:59:42 -0800423 int i;
424 char *p;
425 char *savep;
426 char fs_options[250];
427
428 strlcpy(fs_options, Options.c_str(), sizeof(fs_options));
429 Options = "";
430
431 p = strtok_r(fs_options, ",", &savep);
432 while (p) {
433 /* Look for the flag "p" in the flag list "fl"
434 * If not found, the loop exits with fl[i].name being null.
435 */
436 for (i = 0; mount_flags[i].name; i++) {
437 if (strncmp(p, mount_flags[i].name, strlen(mount_flags[i].name)) == 0) {
438 Flags |= mount_flags[i].flag;
439 break;
440 }
441 }
442
443 if (!mount_flags[i].name) {
444 if (Options.size() > 0)
445 Options += ",";
446 Options += p;
447 }
448 p = strtok_r(NULL, ",", &savep);
449 }
450
451 return true;
452}
453
Dees_Troy51127312012-09-08 13:08:49 -0400454bool TWPartition::Process_Flags(string Flags, bool Display_Error) {
455 char flags[MAX_FSTAB_LINE_LENGTH];
Dees_Troya13d74f2013-03-24 08:54:55 -0500456 int flags_len, index = 0, ptr_len;
Dees_Troy51127312012-09-08 13:08:49 -0400457 char* ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500458 bool skip = false, has_display_name = false, has_storage_name = false, has_backup_name = false;
Dees_Troy51127312012-09-08 13:08:49 -0400459
460 strcpy(flags, Flags.c_str());
461 flags_len = Flags.size();
462 for (index = 0; index < flags_len; index++) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500463 if (flags[index] == 34)
464 skip = !skip;
465 if (!skip && flags[index] == ';')
Dees_Troy51127312012-09-08 13:08:49 -0400466 flags[index] = '\0';
467 }
468
469 index = 0;
470 while (index < flags_len) {
471 while (index < flags_len && flags[index] == '\0')
472 index++;
473 if (index >= flags_len)
474 continue;
475 ptr = flags + index;
Dees_Troya13d74f2013-03-24 08:54:55 -0500476 ptr_len = strlen(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400477 if (strcmp(ptr, "removable") == 0) {
478 Removable = true;
Ethan Yonker06c3f932014-02-02 22:11:14 -0600479 } else if (strncmp(ptr, "storage", 7) == 0) {
480 if (ptr_len == 7) {
Ethan Yonker06c3f932014-02-02 22:11:14 -0600481 Is_Storage = true;
482 } else if (ptr_len == 9) {
483 ptr += 9;
484 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
485 LOGINFO("storage set to true\n");
486 Is_Storage = true;
487 } else {
488 LOGINFO("storage set to false\n");
489 Is_Storage = false;
490 }
491 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500492 } else if (strcmp(ptr, "settingsstorage") == 0) {
493 Is_Storage = true;
Xueferbfce5042015-04-14 02:02:05 +0800494 Is_Settings_Storage = true;
Matt Mowerbf4efa32014-04-14 23:25:26 -0500495 } else if (strcmp(ptr, "andsec") == 0) {
496 Has_Android_Secure = true;
Dees_Troy63c8df72012-09-10 14:02:05 -0400497 } else if (strcmp(ptr, "canbewiped") == 0) {
498 Can_Be_Wiped = true;
Hashcodedabfd492013-08-29 22:45:30 -0700499 } else if (strcmp(ptr, "usermrf") == 0) {
500 Use_Rm_Rf = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500501 } else if (ptr_len > 7 && strncmp(ptr, "backup=", 7) == 0) {
502 ptr += 7;
503 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y')
504 Can_Be_Backed_Up = true;
505 else
506 Can_Be_Backed_Up = false;
Dees_Troy63c8df72012-09-10 14:02:05 -0400507 } else if (strcmp(ptr, "wipeingui") == 0) {
508 Can_Be_Wiped = true;
509 Wipe_Available_in_GUI = true;
510 } else if (strcmp(ptr, "wipeduringfactoryreset") == 0) {
511 Can_Be_Wiped = true;
512 Wipe_Available_in_GUI = true;
513 Wipe_During_Factory_Reset = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500514 } else if (ptr_len > 15 && strncmp(ptr, "subpartitionof=", 15) == 0) {
Dees_Troy2c4c26f2013-01-28 15:26:43 +0000515 ptr += 15;
Dees_Troy51127312012-09-08 13:08:49 -0400516 Is_SubPartition = true;
517 SubPartition_Of = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000518 } else if (strcmp(ptr, "ignoreblkid") == 0) {
519 Ignore_Blkid = true;
Dees_Troy16c2b312013-01-15 16:51:18 +0000520 } else if (strcmp(ptr, "retainlayoutversion") == 0) {
521 Retain_Layout_Version = true;
Dees_Troya13d74f2013-03-24 08:54:55 -0500522 } else if (ptr_len > 8 && strncmp(ptr, "symlink=", 8) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400523 ptr += 8;
524 Symlink_Path = ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500525 } else if (ptr_len > 8 && strncmp(ptr, "display=", 8) == 0) {
526 has_display_name = true;
Dees_Troy51127312012-09-08 13:08:49 -0400527 ptr += 8;
Dees_Troya13d74f2013-03-24 08:54:55 -0500528 if (*ptr == '\"') ptr++;
Dees_Troy51127312012-09-08 13:08:49 -0400529 Display_Name = ptr;
Dees_Troya13d74f2013-03-24 08:54:55 -0500530 if (Display_Name.substr(Display_Name.size() - 1, 1) == "\"") {
531 Display_Name.resize(Display_Name.size() - 1);
532 }
533 } else if (ptr_len > 11 && strncmp(ptr, "storagename=", 11) == 0) {
534 has_storage_name = true;
535 ptr += 11;
536 if (*ptr == '\"') ptr++;
537 Storage_Name = ptr;
538 if (Storage_Name.substr(Storage_Name.size() - 1, 1) == "\"") {
539 Storage_Name.resize(Storage_Name.size() - 1);
540 }
541 } else if (ptr_len > 11 && strncmp(ptr, "backupname=", 10) == 0) {
542 has_backup_name = true;
543 ptr += 10;
544 if (*ptr == '\"') ptr++;
545 Backup_Display_Name = ptr;
546 if (Backup_Display_Name.substr(Backup_Display_Name.size() - 1, 1) == "\"") {
547 Backup_Display_Name.resize(Backup_Display_Name.size() - 1);
548 }
549 } else if (ptr_len > 10 && strncmp(ptr, "blocksize=", 10) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400550 ptr += 10;
Ethan Yonkera2719152015-05-28 09:44:41 -0500551 Format_Block_Size = (unsigned long)(atol(ptr));
Dees_Troya13d74f2013-03-24 08:54:55 -0500552 } else if (ptr_len > 7 && strncmp(ptr, "length=", 7) == 0) {
Dees_Troy51127312012-09-08 13:08:49 -0400553 ptr += 7;
554 Length = atoi(ptr);
Dees_Troy83bd4832013-05-04 12:39:56 +0000555 } else if (ptr_len > 17 && strncmp(ptr, "canencryptbackup=", 17) == 0) {
556 ptr += 17;
557 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y')
558 Can_Encrypt_Backup = true;
559 else
560 Can_Encrypt_Backup = false;
561 } else if (ptr_len > 21 && strncmp(ptr, "userdataencryptbackup=", 21) == 0) {
562 ptr += 21;
563 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
564 Can_Encrypt_Backup = true;
565 Use_Userdata_Encryption = true;
566 } else {
567 Use_Userdata_Encryption = false;
568 }
Hashcode62bd9e02013-11-19 21:59:42 -0800569 } else if (ptr_len > 8 && strncmp(ptr, "fsflags=", 8) == 0) {
570 ptr += 8;
571 if (*ptr == '\"') ptr++;
572
573 Mount_Options = ptr;
574 if (Mount_Options.substr(Mount_Options.size() - 1, 1) == "\"") {
575 Mount_Options.resize(Mount_Options.size() - 1);
576 }
577 Process_FS_Flags(Mount_Options, Mount_Flags);
Ethan Yonker253368a2014-11-25 15:00:52 -0600578 } else if ((ptr_len > 12 && strncmp(ptr, "encryptable=", 12) == 0) || (ptr_len > 13 && strncmp(ptr, "forceencrypt=", 13) == 0)) {
579 ptr += 12;
580 if (*ptr == '=') ptr++;
581 if (*ptr == '\"') ptr++;
582
583 Crypto_Key_Location = ptr;
584 if (Crypto_Key_Location.substr(Crypto_Key_Location.size() - 1, 1) == "\"") {
585 Crypto_Key_Location.resize(Crypto_Key_Location.size() - 1);
586 }
587 } else if (ptr_len > 8 && strncmp(ptr, "mounttodecrypt", 14) == 0) {
588 Mount_To_Decrypt = true;
Ethan Yonker96af84a2015-01-05 14:58:36 -0600589 } else if (strncmp(ptr, "flashimg", 8) == 0) {
590 if (ptr_len == 8) {
591 Can_Flash_Img = true;
592 } else if (ptr_len == 10) {
593 ptr += 9;
594 if (*ptr == '1' || *ptr == 'y' || *ptr == 'Y') {
595 Can_Flash_Img = true;
596 } else {
597 Can_Flash_Img = false;
598 }
599 }
Dees_Troy51127312012-09-08 13:08:49 -0400600 } else {
601 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000602 LOGERR("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400603 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000604 LOGINFO("Unhandled flag: '%s'\n", ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400605 }
606 while (index < flags_len && flags[index] != '\0')
607 index++;
608 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500609 if (has_display_name && !has_storage_name)
610 Storage_Name = Display_Name;
611 if (!has_display_name && has_storage_name)
612 Display_Name = Storage_Name;
Dees_Troy74fb2e92013-04-15 14:35:47 +0000613 if (has_display_name && !has_backup_name && Backup_Display_Name != "Android Secure")
Dees_Troya13d74f2013-03-24 08:54:55 -0500614 Backup_Display_Name = Display_Name;
615 if (!has_display_name && has_backup_name)
616 Display_Name = Backup_Display_Name;
Dees_Troy51127312012-09-08 13:08:49 -0400617 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400618}
619
Dees_Troy5bf43922012-09-07 16:07:55 -0400620bool TWPartition::Is_File_System(string File_System) {
621 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -0400622 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400623 File_System == "ext4" ||
624 File_System == "vfat" ||
625 File_System == "ntfs" ||
626 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -0500627 File_System == "exfat" ||
Dees_Troye5017042013-08-29 16:38:55 +0000628 File_System == "f2fs" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400629 File_System == "auto")
630 return true;
631 else
632 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400633}
634
Dees_Troy5bf43922012-09-07 16:07:55 -0400635bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400636 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400637 return true;
638 else
639 return false;
640}
641
Dees_Troy51127312012-09-08 13:08:49 -0400642bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400643 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400644 if (mkdir(Path.c_str(), 0777) == -1) {
645 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -0500646 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(Path)(strerror(errno)));
Dees_Troy51127312012-09-08 13:08:49 -0400647 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000648 LOGINFO("Can not create '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400649 return false;
650 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000651 LOGINFO("Created '%s' folder.\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400652 return true;
653 }
654 }
655 return true;
656}
657
Dees_Troy5bf43922012-09-07 16:07:55 -0400658void TWPartition::Setup_File_System(bool Display_Error) {
659 struct statfs st;
660
661 Can_Be_Mounted = true;
662 Can_Be_Wiped = true;
663
Dees_Troy5bf43922012-09-07 16:07:55 -0400664 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -0400665 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400666 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
667 Backup_Name = Display_Name;
668 Backup_Method = FILES;
669}
670
671void TWPartition::Setup_Image(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400672 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
673 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -0800674 if (Current_File_System == "emmc")
Dees_Troy5bf43922012-09-07 16:07:55 -0400675 Backup_Method = DD;
Gary Peck82599a82012-11-21 16:23:12 -0800676 else if (Current_File_System == "mtd" || Current_File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400677 Backup_Method = FLASH_UTILS;
678 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000679 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 -0400680 if (Find_Partition_Size()) {
681 Used = Size;
682 Backup_Size = Size;
Dees_Troy51a0e822012-09-05 15:24:24 -0400683 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400684 if (Display_Error)
Dees Troyd932ce12013-10-18 17:12:59 +0000685 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400686 else
Dees Troyd932ce12013-10-18 17:12:59 +0000687 LOGINFO("Unable to find partition size for '%s'\n", Mount_Point.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -0400688 }
689}
690
Dees_Troye58d5262012-09-21 12:27:57 -0400691void TWPartition::Setup_AndSec(void) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500692 Backup_Display_Name = "Android Secure";
Dees_Troye58d5262012-09-21 12:27:57 -0400693 Backup_Name = "and-sec";
Dees_Troya13d74f2013-03-24 08:54:55 -0500694 Can_Be_Backed_Up = true;
Dees_Troye58d5262012-09-21 12:27:57 -0400695 Has_Android_Secure = true;
696 Symlink_Path = Mount_Point + "/.android_secure";
697 Symlink_Mount_Point = "/and-sec";
698 Backup_Path = Symlink_Mount_Point;
699 Make_Dir("/and-sec", true);
700 Recreate_AndSec_Folder();
Ethan Yonkerd4d10732014-02-03 15:27:52 -0600701 Mount_Storage_Retry();
Dees_Troye58d5262012-09-21 12:27:57 -0400702}
703
that9e0593e2014-10-08 00:01:24 +0200704void TWPartition::Setup_Data_Media() {
Ethan Yonker6277c792014-09-15 14:54:30 -0500705 LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
706 Storage_Name = "Internal Storage";
707 Has_Data_Media = true;
708 Is_Storage = true;
709 Is_Settings_Storage = true;
710 Storage_Path = "/data/media";
711 Symlink_Path = Storage_Path;
712 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
713 Make_Dir("/emmc", false);
714 Symlink_Mount_Point = "/emmc";
715 } else {
716 Make_Dir("/sdcard", false);
717 Symlink_Mount_Point = "/sdcard";
718 }
719 if (Mount(false) && TWFunc::Path_Exists("/data/media/0")) {
720 Storage_Path = "/data/media/0";
721 Symlink_Path = Storage_Path;
722 DataManager::SetValue(TW_INTERNAL_PATH, "/data/media/0");
723 UnMount(true);
724 }
Ethan Yonker6277c792014-09-15 14:54:30 -0500725 DataManager::SetValue("tw_has_internal", 1);
726 DataManager::SetValue("tw_has_data_media", 1);
727 du.add_absolute_dir("/data/media");
728}
729
Dees_Troy5bf43922012-09-07 16:07:55 -0400730void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
731 char device[512], realDevice[512];
732
733 strcpy(device, Block.c_str());
734 memset(realDevice, 0, sizeof(realDevice));
735 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
736 {
737 strcpy(device, realDevice);
738 memset(realDevice, 0, sizeof(realDevice));
739 }
740
741 if (device[0] != '/') {
742 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000743 LOGERR("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400744 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000745 LOGINFO("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400746 return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400747 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400748 Block = device;
749 return;
750 }
751}
752
Dees_Troy8e337f32012-10-13 22:07:49 -0400753void TWPartition::Mount_Storage_Retry(void) {
754 // On some devices, storage doesn't want to mount right away, retry and sleep
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500755 if (!Mount(true)) {
Dees_Troy8e337f32012-10-13 22:07:49 -0400756 int retry_count = 5;
757 while (retry_count > 0 && !Mount(false)) {
758 usleep(500000);
759 retry_count--;
760 }
761 Mount(true);
762 }
763}
764
Dees_Troy38bd7602012-09-14 13:33:53 -0400765bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
766 FILE *fp = NULL;
767 char line[255];
768
769 fp = fopen("/proc/mtd", "rt");
770 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000771 LOGERR("Device does not support /proc/mtd\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400772 return false;
773 }
774
775 while (fgets(line, sizeof(line), fp) != NULL)
776 {
777 char device[32], label[32];
778 unsigned long size = 0;
779 char* fstype = NULL;
780 int deviceId;
781
782 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
783
784 // Skip header and blank lines
785 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
786 continue;
787
788 // Strip off the trailing " from the label
789 label[strlen(label)-1] = '\0';
790
791 if (strcmp(label, MTD_Name.c_str()) == 0) {
792 // We found our device
793 // Strip off the trailing : from the device
794 device[strlen(device)-1] = '\0';
795 if (sscanf(device,"mtd%d", &deviceId) == 1) {
796 sprintf(device, "/dev/block/mtdblock%d", deviceId);
797 Primary_Block_Device = device;
Dees_Troy76543db2013-06-19 16:24:30 +0000798 fclose(fp);
799 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -0400800 }
801 }
802 }
803 fclose(fp);
804
805 return false;
806}
807
Dees_Troy51127312012-09-08 13:08:49 -0400808bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
809 struct statfs st;
810 string Local_Path = Mount_Point + "/.";
811
812 if (!Mount(Display_Error))
813 return false;
814
815 if (statfs(Local_Path.c_str(), &st) != 0) {
816 if (!Removable) {
817 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000818 LOGERR("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400819 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000820 LOGINFO("Unable to statfs '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400821 }
822 return false;
823 }
824 Size = (st.f_blocks * st.f_bsize);
825 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
826 Free = (st.f_bfree * st.f_bsize);
827 Backup_Size = Used;
828 return true;
829}
830
831bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400832 FILE* fp;
833 char command[255], line[512];
834 int include_block = 1;
835 unsigned int min_len;
836
837 if (!Mount(Display_Error))
838 return false;
839
Dees_Troy38bd7602012-09-14 13:33:53 -0400840 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -0400841 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +0200842 TWFunc::Exec_Cmd(command);
Dees_Troy51127312012-09-08 13:08:49 -0400843 fp = fopen("/tmp/dfoutput.txt", "rt");
844 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000845 LOGINFO("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400846 return false;
Dees_Troy51127312012-09-08 13:08:49 -0400847 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400848
849 while (fgets(line, sizeof(line), fp) != NULL)
850 {
851 unsigned long blocks, used, available;
852 char device[64];
853 char tmpString[64];
854
855 if (strncmp(line, "Filesystem", 10) == 0)
856 continue;
857 if (strlen(line) < min_len) {
858 include_block = 0;
859 continue;
860 }
861 if (include_block) {
862 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
863 } else {
864 // The device block string is so long that the df information is on the next line
865 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -0400866 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400867 while (tmpString[space_count] == 32)
868 space_count++;
869 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
870 }
871
872 // Adjust block size to byte size
873 Size = blocks * 1024ULL;
874 Used = used * 1024ULL;
875 Free = available * 1024ULL;
876 Backup_Size = Used;
877 }
878 fclose(fp);
879 return true;
880}
881
Ethan Yonkerd18a8212015-12-14 10:17:00 -0600882unsigned long long TWPartition::IOCTL_Get_Block_Size() {
883 unsigned long block_device_size;
884 int ret = 0;
885
886 Find_Actual_Block_Device();
887 int fd = open(Actual_Block_Device.c_str(), O_RDONLY);
888 if (fd < 0) {
889 LOGINFO("Find_Partition_Size: Failed to open '%s', (%s)\n", Actual_Block_Device.c_str(), strerror(errno));
890 } else {
891 ret = ioctl(fd, BLKGETSIZE, &block_device_size);
892 close(fd);
893 if (ret) {
894 LOGINFO("Find_Partition_Size: ioctl error: (%s)\n", strerror(errno));
895 } else {
896 return (unsigned long long)(block_device_size) * 512LLU;
897 }
898 }
899 return 0;
900}
901
Dees_Troy5bf43922012-09-07 16:07:55 -0400902bool TWPartition::Find_Partition_Size(void) {
903 FILE* fp;
904 char line[512];
905 string tmpdevice;
906
igoriok87e3d932013-01-31 21:03:53 +0200907 fp = fopen("/proc/dumchar_info", "rt");
908 if (fp != NULL) {
909 while (fgets(line, sizeof(line), fp) != NULL)
910 {
911 char label[32], device[32];
912 unsigned long size = 0;
913
thatd43bf2d2014-09-21 23:13:02 +0200914 sscanf(line, "%s %lx %*x %*u %s", label, &size, device);
igoriok87e3d932013-01-31 21:03:53 +0200915
bigbiff bigbiff34684ff2013-12-01 21:03:45 -0500916 // Skip header, annotation and blank lines
igoriok87e3d932013-01-31 21:03:53 +0200917 if ((strncmp(device, "/dev/", 5) != 0) || (strlen(line) < 8))
918 continue;
919
920 tmpdevice = "/dev/";
921 tmpdevice += label;
922 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
923 Size = size;
924 fclose(fp);
925 return true;
926 }
927 }
928 }
929
Ethan Yonkerd18a8212015-12-14 10:17:00 -0600930 unsigned long long ioctl_size = IOCTL_Get_Block_Size();
931 if (ioctl_size) {
932 Size = ioctl_size;
933 return true;
934 }
935
Dees_Troy5bf43922012-09-07 16:07:55 -0400936 // In this case, we'll first get the partitions we care about (with labels)
937 fp = fopen("/proc/partitions", "rt");
938 if (fp == NULL)
939 return false;
940
941 while (fgets(line, sizeof(line), fp) != NULL)
942 {
943 unsigned long major, minor, blocks;
944 char device[512];
945 char tmpString[64];
946
Dees_Troy63c8df72012-09-10 14:02:05 -0400947 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -0400948 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
949
950 tmpdevice = "/dev/block/";
951 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -0400952 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400953 // Adjust block size to byte size
954 Size = blocks * 1024ULL;
955 fclose(fp);
956 return true;
957 }
958 }
959 fclose(fp);
960 return false;
961}
962
Dees_Troy5bf43922012-09-07 16:07:55 -0400963bool TWPartition::Is_Mounted(void) {
964 if (!Can_Be_Mounted)
965 return false;
966
967 struct stat st1, st2;
968 string test_path;
969
970 // Check to see if the mount point directory exists
971 test_path = Mount_Point + "/.";
972 if (stat(test_path.c_str(), &st1) != 0) return false;
973
974 // Check to see if the directory above the mount point exists
975 test_path = Mount_Point + "/../.";
976 if (stat(test_path.c_str(), &st2) != 0) return false;
977
978 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
979 int ret = (st1.st_dev != st2.st_dev) ? true : false;
980
981 return ret;
982}
983
984bool TWPartition::Mount(bool Display_Error) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000985 int exfat_mounted = 0;
Ethan Yonkereb32b1f2015-05-18 10:23:03 -0500986 unsigned long flags = Mount_Flags;
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000987
Dees_Troy5bf43922012-09-07 16:07:55 -0400988 if (Is_Mounted()) {
989 return true;
990 } else if (!Can_Be_Mounted) {
991 return false;
992 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400993
994 Find_Actual_Block_Device();
995
996 // Check the current file system before mounting
997 Check_FS_Type();
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000998 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
Dees_Troye34c1332013-02-06 19:13:00 +0000999 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 +00001000 LOGINFO("cmd: %s\n", cmd.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001001 string result;
1002 if (TWFunc::Exec_Cmd(cmd, result) != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001003 LOGINFO("exfat-fuse failed to mount with result '%s', trying vfat\n", result.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001004 Current_File_System = "vfat";
1005 } else {
1006#ifdef TW_NO_EXFAT_FUSE
1007 UnMount(false);
1008 // We'll let the kernel handle it but using exfat-fuse to detect if the file system is actually exfat
1009 // Some kernels let us mount vfat as exfat which doesn't work out too well
1010#else
1011 exfat_mounted = 1;
1012#endif
1013 }
1014 }
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001015
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001016 if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfs-3g") || TWFunc::Path_Exists("/sbin/mount.ntfs"))) {
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001017 string cmd;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001018 string Ntfsmount_Binary = "";
1019
1020 if (TWFunc::Path_Exists("/sbin/ntfs-3g"))
1021 Ntfsmount_Binary = "ntfs-3g";
1022 else if (TWFunc::Path_Exists("/sbin/mount.ntfs"))
1023 Ntfsmount_Binary = "mount.ntfs";
1024
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001025 if (Mount_Read_Only)
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001026 cmd = "/sbin/" + Ntfsmount_Binary + " -o ro " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001027 else
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001028 cmd = "/sbin/" + Ntfsmount_Binary + " " + Actual_Block_Device + " " + Mount_Point;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001029 LOGINFO("cmd: '%s'\n", cmd.c_str());
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001030
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001031 if (TWFunc::Exec_Cmd(cmd) == 0) {
1032 return true;
1033 } else {
1034 LOGINFO("ntfs-3g failed to mount, trying regular mount method.\n");
1035 }
1036 }
1037
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001038 if (Mount_Read_Only)
1039 flags |= MS_RDONLY;
1040
Dees_Troy22042032012-12-18 21:23:08 +00001041 if (Fstab_File_System == "yaffs2") {
1042 // mount an MTD partition as a YAFFS2 filesystem.
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001043 flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
1044 if (Mount_Read_Only)
1045 flags |= MS_RDONLY;
Dees_Troy76543db2013-06-19 16:24:30 +00001046 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags, NULL) < 0) {
1047 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Fstab_File_System.c_str(), flags | MS_RDONLY, NULL) < 0) {
1048 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001049 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001050 else
1051 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1052 return false;
1053 } else {
1054 LOGINFO("Mounted '%s' (MTD) as RO\n", Mount_Point.c_str());
1055 return true;
1056 }
1057 } else {
1058 struct stat st;
1059 string test_path = Mount_Point;
1060 if (stat(test_path.c_str(), &st) < 0) {
1061 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001062 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy76543db2013-06-19 16:24:30 +00001063 else
1064 LOGINFO("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
1065 return false;
1066 }
1067 mode_t new_mode = st.st_mode | S_IXUSR | S_IXGRP | S_IXOTH;
1068 if (new_mode != st.st_mode) {
1069 LOGINFO("Fixing execute permissions for %s\n", Mount_Point.c_str());
1070 if (chmod(Mount_Point.c_str(), new_mode) < 0) {
1071 if (Display_Error)
1072 LOGERR("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1073 else
1074 LOGINFO("Couldn't fix permissions for %s: %s\n", Mount_Point.c_str(), strerror(errno));
1075 return false;
1076 }
1077 }
Dees_Troy22042032012-12-18 21:23:08 +00001078 return true;
Dees_Troy76543db2013-06-19 16:24:30 +00001079 }
thatc7572eb2015-03-31 18:55:30 +02001080 }
1081
1082 string mount_fs = Current_File_System;
1083 if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sys/module/texfat"))
1084 mount_fs = "texfat";
1085
1086 if (!exfat_mounted &&
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001087 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, Mount_Options.c_str()) != 0 &&
1088 mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), mount_fs.c_str(), flags, NULL) != 0) {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001089#ifdef TW_NO_EXFAT_FUSE
1090 if (Current_File_System == "exfat") {
Dees_Troy2673cec2013-04-02 20:22:16 +00001091 LOGINFO("Mounting exfat failed, trying vfat...\n");
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001092 if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), "vfat", 0, NULL) != 0) {
Dees_Troy85f44ed2013-01-09 18:42:36 +00001093 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001094 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy85f44ed2013-01-09 18:42:36 +00001095 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001096 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001097 LOGINFO("Actual block device: '%s', current file system: '%s', flags: 0x%8x, options: '%s'\n", Actual_Block_Device.c_str(), Current_File_System.c_str(), flags, Mount_Options.c_str());
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001098 return false;
Dees_Troy85f44ed2013-01-09 18:42:36 +00001099 }
Dees_Troyb05ddee2013-01-28 20:24:50 +00001100 } else {
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001101#endif
bigbiff bigbiff26774a02014-03-29 18:22:00 -04001102 if (!Removable && Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001103 gui_msg(Msg(msg::kError, "fail_mount=Failed to mount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001104 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001105 LOGINFO("Unable to mount '%s'\n", Mount_Point.c_str());
1106 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 +00001107 return false;
1108#ifdef TW_NO_EXFAT_FUSE
Dees_Troy85f44ed2013-01-09 18:42:36 +00001109 }
1110#endif
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001111 }
Ethan Yonker253368a2014-11-25 15:00:52 -06001112
Dees_Troy3f5c4e82013-02-01 15:16:59 +00001113 if (Removable)
1114 Update_Size(Display_Error);
1115
xiaolu9416f4f2015-06-04 08:22:23 +08001116 if (!Symlink_Mount_Point.empty() && TWFunc::Path_Exists(Symlink_Path)) {
codelover2a3d4ce2015-03-14 20:26:49 +08001117 string Command = "mount -o bind '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
Vojtech Bocek05534202013-09-11 08:11:56 +02001118 TWFunc::Exec_Cmd(Command);
Dees_Troy5bf43922012-09-07 16:07:55 -04001119 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001120 return true;
1121}
1122
1123bool TWPartition::UnMount(bool Display_Error) {
1124 if (Is_Mounted()) {
1125 int never_unmount_system;
1126
1127 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
1128 if (never_unmount_system == 1 && Mount_Point == "/system")
1129 return true; // Never unmount system if you're not supposed to unmount it
1130
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001131 if (Is_Storage)
Ethan Yonker726a0202014-12-16 20:01:38 -06001132 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001133
Dees_Troy38bd7602012-09-14 13:33:53 -04001134 if (!Symlink_Mount_Point.empty())
1135 umount(Symlink_Mount_Point.c_str());
1136
Dees_Troyb05ddee2013-01-28 20:24:50 +00001137 umount(Mount_Point.c_str());
1138 if (Is_Mounted()) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001139 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -05001140 gui_msg(Msg(msg::kError, "fail_unmount=Failed to unmount '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy5bf43922012-09-07 16:07:55 -04001141 else
Dees_Troy2673cec2013-04-02 20:22:16 +00001142 LOGINFO("Unable to unmount '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -04001143 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001144 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -04001145 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001146 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001147 } else {
1148 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001149 }
1150}
1151
Gary Peck43acadf2012-11-21 21:19:01 -08001152bool TWPartition::Wipe(string New_File_System) {
Ethan Yonker726a0202014-12-16 20:01:38 -06001153 bool wiped = false, update_crypt = false, recreate_media = true;
Dees_Troy16c2b312013-01-15 16:51:18 +00001154 int check;
1155 string Layout_Filename = Mount_Point + "/.layout_version";
1156
Dees_Troy38bd7602012-09-14 13:33:53 -04001157 if (!Can_Be_Wiped) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001158 gui_msg(Msg(msg::kError, "cannot_wipe=Partition {1} cannot be wiped.\n")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001159 return false;
1160 }
1161
Dees_Troyc51f1f92012-09-20 15:32:13 -04001162 if (Mount_Point == "/cache")
Dees_Troy2673cec2013-04-02 20:22:16 +00001163 Log_Offset = 0;
Dees_Troyc51f1f92012-09-20 15:32:13 -04001164
Dees_Troy16c2b312013-01-15 16:51:18 +00001165 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
1166 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
1167 else
1168 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -04001169
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001170 if (Has_Data_Media && Current_File_System == New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +00001171 wiped = Wipe_Data_Without_Wiping_Media();
Ethan Yonker5eac2222014-06-11 12:22:55 -05001172 recreate_media = false;
Dees_Troy16c2b312013-01-15 16:51:18 +00001173 } else {
Dees_Troy16c2b312013-01-15 16:51:18 +00001174 DataManager::GetValue(TW_RM_RF_VAR, check);
1175
Hashcodedabfd492013-08-29 22:45:30 -07001176 if (check || Use_Rm_Rf)
Dees_Troy16c2b312013-01-15 16:51:18 +00001177 wiped = Wipe_RMRF();
1178 else if (New_File_System == "ext4")
1179 wiped = Wipe_EXT4();
1180 else if (New_File_System == "ext2" || New_File_System == "ext3")
1181 wiped = Wipe_EXT23(New_File_System);
1182 else if (New_File_System == "vfat")
1183 wiped = Wipe_FAT();
1184 else if (New_File_System == "exfat")
1185 wiped = Wipe_EXFAT();
1186 else if (New_File_System == "yaffs2")
1187 wiped = Wipe_MTD();
Dees_Troye5017042013-08-29 16:38:55 +00001188 else if (New_File_System == "f2fs")
1189 wiped = Wipe_F2FS();
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001190 else if (New_File_System == "ntfs")
1191 wiped = Wipe_NTFS();
Dees_Troy16c2b312013-01-15 16:51:18 +00001192 else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001193 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 +00001194 unlink("/.layout_version");
1195 return false;
1196 }
1197 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -08001198 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001199
Gary Pecke8bc5d72012-12-21 06:45:25 -08001200 if (wiped) {
Dees_Troy1c1ac442013-01-17 21:42:14 +00001201 if (Mount_Point == "/cache")
1202 DataManager::Output_Version();
1203
Dees_Troy16c2b312013-01-15 16:51:18 +00001204 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
1205 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
1206
1207 if (update_crypt) {
1208 Setup_File_System(false);
1209 if (Is_Encrypted && !Is_Decrypted) {
1210 // just wiped an encrypted partition back to its unencrypted state
1211 Is_Encrypted = false;
1212 Is_Decrypted = false;
1213 Decrypted_Block_Device = "";
1214 if (Mount_Point == "/data") {
1215 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
1216 DataManager::SetValue(TW_IS_DECRYPTED, 0);
1217 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001218 }
1219 }
Ethan Yonker5eac2222014-06-11 12:22:55 -05001220
1221 if (Mount_Point == "/data" && Has_Data_Media && recreate_media) {
1222 Recreate_Media_Folder();
1223 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001224 }
Ethan Yonker726a0202014-12-16 20:01:38 -06001225 if (Is_Storage) {
1226 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001227 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001228 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -04001229}
1230
Gary Peck43acadf2012-11-21 21:19:01 -08001231bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -08001232 if (Is_File_System(Current_File_System))
1233 return Wipe(Current_File_System);
1234 else
1235 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -08001236}
1237
Dees_Troye58d5262012-09-21 12:27:57 -04001238bool TWPartition::Wipe_AndSec(void) {
1239 if (!Has_Android_Secure)
1240 return false;
1241
Dees_Troye58d5262012-09-21 12:27:57 -04001242 if (!Mount(true))
1243 return false;
1244
Ethan Yonker74db1572015-10-28 12:44:49 -05001245 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001246 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001247 return true;
Dees_Troye58d5262012-09-21 12:27:57 -04001248}
1249
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001250bool TWPartition::Can_Repair() {
Ethan Yonkera2719152015-05-28 09:44:41 -05001251 if (Mount_Read_Only)
1252 return false;
Matt Mower18794c82015-11-11 16:22:45 -06001253 if (Current_File_System == "vfat" && TWFunc::Path_Exists("/sbin/fsck.fat"))
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001254 return true;
1255 else if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/e2fsck"))
1256 return true;
1257 else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/fsck.exfat"))
1258 return true;
1259 else if (Current_File_System == "f2fs" && TWFunc::Path_Exists("/sbin/fsck.f2fs"))
1260 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001261 else if (Current_File_System == "ntfs" && (TWFunc::Path_Exists("/sbin/ntfsfix") || TWFunc::Path_Exists("/sbin/fsck.ntfs")))
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001262 return true;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001263 return false;
1264}
1265
1266bool TWPartition::Repair() {
1267 string command;
1268
1269 if (Current_File_System == "vfat") {
Matt Mower18794c82015-11-11 16:22:45 -06001270 if (!TWFunc::Path_Exists("/sbin/fsck.fat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001271 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001272 return false;
1273 }
1274 if (!UnMount(true))
1275 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001276 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.fat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001277 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06001278 command = "/sbin/fsck.fat -y " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001279 LOGINFO("Repair command: %s\n", command.c_str());
1280 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001281 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001282 return true;
1283 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001284 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001285 return false;
1286 }
1287 }
1288 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1289 if (!TWFunc::Path_Exists("/sbin/e2fsck")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001290 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001291 return false;
1292 }
1293 if (!UnMount(true))
1294 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001295 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("e2fsck"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001296 Find_Actual_Block_Device();
Ethan Yonkera2719152015-05-28 09:44:41 -05001297 command = "/sbin/e2fsck -fp " + Actual_Block_Device;
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001298 LOGINFO("Repair command: %s\n", command.c_str());
1299 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001300 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001301 return true;
1302 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001303 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001304 return false;
1305 }
1306 }
1307 if (Current_File_System == "exfat") {
1308 if (!TWFunc::Path_Exists("/sbin/fsck.exfat")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001309 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001310 return false;
1311 }
1312 if (!UnMount(true))
1313 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001314 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.exfat"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001315 Find_Actual_Block_Device();
1316 command = "/sbin/fsck.exfat " + Actual_Block_Device;
1317 LOGINFO("Repair command: %s\n", command.c_str());
1318 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001319 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001320 return true;
1321 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001322 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001323 return false;
1324 }
1325 }
1326 if (Current_File_System == "f2fs") {
1327 if (!TWFunc::Path_Exists("/sbin/fsck.f2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001328 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001329 return false;
1330 }
1331 if (!UnMount(true))
1332 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001333 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)("fsck.f2fs"));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001334 Find_Actual_Block_Device();
1335 command = "/sbin/fsck.f2fs " + Actual_Block_Device;
1336 LOGINFO("Repair command: %s\n", command.c_str());
1337 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001338 gui_msg("done=Done.");
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001339 return true;
1340 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001341 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001342 return false;
1343 }
1344 }
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001345 if (Current_File_System == "ntfs") {
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001346 string Ntfsfix_Binary;
1347 if (TWFunc::Path_Exists("/sbin/ntfsfix"))
1348 Ntfsfix_Binary = "ntfsfix";
1349 else if (TWFunc::Path_Exists("/sbin/fsck.ntfs"))
1350 Ntfsfix_Binary = "fsck.ntfs";
1351 else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001352 gui_msg(Msg(msg::kError, "repair_not_exist={1} does not exist! Cannot repair!")("ntfsfix"));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001353 return false;
1354 }
1355 if (!UnMount(true))
1356 return false;
Greg Wallace2d653402015-12-29 14:19:21 -05001357 gui_msg(Msg("repairing_using=Repairing {1} using {2}...")(Display_Name)(Ntfsfix_Binary));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001358 Find_Actual_Block_Device();
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001359 command = "/sbin/" + Ntfsfix_Binary + " " + Actual_Block_Device;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001360 LOGINFO("Repair command: %s\n", command.c_str());
1361 if (TWFunc::Exec_Cmd(command) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001362 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001363 return true;
1364 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001365 gui_msg(Msg(msg::kError, "unable_repair=Unable to repair {1}.")(Display_Name));
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001366 return false;
1367 }
1368 }
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001369 return false;
1370}
1371
Ethan Yonkera2719152015-05-28 09:44:41 -05001372bool TWPartition::Can_Resize() {
1373 if (Mount_Read_Only)
1374 return false;
1375 if ((Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") && TWFunc::Path_Exists("/sbin/resize2fs"))
1376 return true;
1377 return false;
1378}
1379
1380bool TWPartition::Resize() {
1381 string command;
1382
1383 if (Current_File_System == "ext2" || Current_File_System == "ext3" || Current_File_System == "ext4") {
1384 if (!Can_Repair()) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001385 LOGINFO("Cannot resize %s because %s cannot be repaired before resizing.\n", Display_Name.c_str(), Display_Name.c_str());
1386 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001387 return false;
1388 }
1389 if (!TWFunc::Path_Exists("/sbin/resize2fs")) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001390 LOGINFO("resize2fs does not exist! Cannot resize!\n");
1391 gui_msg(Msg(msg::kError, "cannot_resize=Cannot resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001392 return false;
1393 }
1394 // Repair will unmount so no need to do it twice
Ethan Yonker74db1572015-10-28 12:44:49 -05001395 gui_msg(Msg("repair_resize=Repairing {1} before resizing.")( Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001396 if (!Repair())
1397 return false;
Ethan Yonker74db1572015-10-28 12:44:49 -05001398 gui_msg(Msg("resizing=Resizing {1} using {2}...")(Display_Name)("resize2fs"));
Ethan Yonkera2719152015-05-28 09:44:41 -05001399 Find_Actual_Block_Device();
1400 command = "/sbin/resize2fs " + Actual_Block_Device;
1401 if (Length != 0) {
Ethan Yonkerd18a8212015-12-14 10:17:00 -06001402 unsigned long long Actual_Size = IOCTL_Get_Block_Size();
1403 if (Actual_Size == 0)
1404 return false;
Ethan Yonkera2719152015-05-28 09:44:41 -05001405
Ethan Yonkera2719152015-05-28 09:44:41 -05001406 unsigned long long Block_Count;
1407 if (Length < 0) {
1408 // Reduce overall size by this length
1409 Block_Count = (Actual_Size / 1024LLU) - ((unsigned long long)(Length * -1) / 1024LLU);
1410 } else {
1411 // This is the size, not a size reduction
1412 Block_Count = ((unsigned long long)(Length) / 1024LLU);
1413 }
1414 char temp[256];
1415 sprintf(temp, "%llu", Block_Count);
1416 command += " ";
1417 command += temp;
1418 command += "K";
1419 }
1420 LOGINFO("Resize command: %s\n", command.c_str());
1421 if (TWFunc::Exec_Cmd(command) == 0) {
1422 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001423 gui_msg("done=Done.");
Ethan Yonkera2719152015-05-28 09:44:41 -05001424 return true;
1425 } else {
1426 Update_Size(true);
Ethan Yonker74db1572015-10-28 12:44:49 -05001427 gui_msg(Msg(msg::kError, "unable_resize=Unable to resize {1}.")(Display_Name));
Ethan Yonkera2719152015-05-28 09:44:41 -05001428 return false;
1429 }
1430 }
1431 return false;
1432}
1433
bigbiff7abc5fe2015-01-17 16:53:12 -05001434bool TWPartition::Backup(string backup_folder, const unsigned long long *overall_size, const unsigned long long *other_backups_size, pid_t &tar_fork_pid) {
1435 if (Backup_Method == FILES) {
1436 return Backup_Tar(backup_folder, overall_size, other_backups_size, tar_fork_pid);
1437 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001438 else if (Backup_Method == DD)
1439 return Backup_DD(backup_folder);
1440 else if (Backup_Method == FLASH_UTILS)
1441 return Backup_Dump_Image(backup_folder);
Dees_Troy2673cec2013-04-02 20:22:16 +00001442 LOGERR("Unknown backup method for '%s'\n", Mount_Point.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001443 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001444}
1445
Dees_Troy43d8b002012-09-17 16:00:01 -04001446bool TWPartition::Check_MD5(string restore_folder) {
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001447 string Full_Filename, md5file;
Dees_Troy43d8b002012-09-17 16:00:01 -04001448 char split_filename[512];
1449 int index = 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001450 twrpDigest md5sum;
Dees_Troy43d8b002012-09-17 16:00:01 -04001451
Captain Throwbackff5935f2014-09-23 16:08:34 -04001452 sync();
1453
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001454 memset(split_filename, 0, sizeof(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001455 Full_Filename = restore_folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04001456 if (!TWFunc::Path_Exists(Full_Filename)) {
1457 // This is a split archive, we presume
1458 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
Dees_Troy2673cec2013-04-02 20:22:16 +00001459 LOGINFO("split_filename: %s\n", split_filename);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001460 md5file = split_filename;
1461 md5file += ".md5";
1462 if (!TWFunc::Path_Exists(md5file)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001463 gui_msg(Msg(msg::kError, "no_md5_found=No md5 file found for '{1}'. Please unselect Enable MD5 verification to restore.")(split_filename));
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001464 return false;
1465 }
1466 md5sum.setfn(split_filename);
Dees_Troy83bd4832013-05-04 12:39:56 +00001467 while (index < 1000) {
1468 if (TWFunc::Path_Exists(split_filename) && md5sum.verify_md5digest() != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001469 gui_msg(Msg(msg::kError, "md5_fail_match=MD5 failed to match on '{1}'.")(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001470 return false;
1471 }
1472 index++;
1473 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001474 md5sum.setfn(split_filename);
Dees_Troy43d8b002012-09-17 16:00:01 -04001475 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001476 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001477 } else {
1478 // Single file archive
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001479 md5file = Full_Filename + ".md5";
1480 if (!TWFunc::Path_Exists(md5file)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001481 gui_msg(Msg(msg::kError, "no_md5_found=No md5 file found for '{1}'. Please unselect Enable MD5 verification to restore.")(split_filename));
bigbiff bigbiff65a4c732013-03-15 15:17:50 -04001482 return false;
1483 }
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001484 md5sum.setfn(Full_Filename);
1485 if (md5sum.verify_md5digest() != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001486 gui_msg(Msg(msg::kError, "md5_fail_match=MD5 failed to match on '{1}'.")(split_filename));
Dees_Troy43d8b002012-09-17 16:00:01 -04001487 return false;
1488 } else
1489 return true;
1490 }
1491 return false;
1492}
1493
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001494bool 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 -08001495 string Restore_File_System;
1496
Ethan Yonker74db1572015-10-28 12:44:49 -05001497 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, gui_parse_text("{@restoring}"));
Dees_Troy2673cec2013-04-02 20:22:16 +00001498 LOGINFO("Restore filename is: %s\n", Backup_FileName.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001499
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001500 Restore_File_System = Get_Restore_File_System(restore_folder);
1501
1502 if (Is_File_System(Restore_File_System))
1503 return Restore_Tar(restore_folder, Restore_File_System, total_restore_size, already_restored_size);
1504 else if (Is_Image(Restore_File_System)) {
Ethan Yonkerf66324f2015-01-09 16:46:57 -06001505 return Restore_Image(restore_folder, total_restore_size, already_restored_size, Restore_File_System);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001506 }
1507
1508 LOGERR("Unknown restore method for '%s'\n", Mount_Point.c_str());
1509 return false;
1510}
1511
1512string TWPartition::Get_Restore_File_System(string restore_folder) {
1513 size_t first_period, second_period;
1514 string Restore_File_System;
1515
Gary Peck43acadf2012-11-21 21:19:01 -08001516 // Parse backup filename to extract the file system before wiping
1517 first_period = Backup_FileName.find(".");
1518 if (first_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001519 LOGERR("Unable to find file system (first period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001520 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001521 }
1522 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
1523 second_period = Restore_File_System.find(".");
1524 if (second_period == string::npos) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001525 LOGERR("Unable to find file system (second period).\n");
thatd43bf2d2014-09-21 23:13:02 +02001526 return string();
Gary Peck43acadf2012-11-21 21:19:01 -08001527 }
1528 Restore_File_System.resize(second_period);
Dees_Troy2673cec2013-04-02 20:22:16 +00001529 LOGINFO("Restore file system is: '%s'.\n", Restore_File_System.c_str());
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001530 return Restore_File_System;
Dees_Troy51a0e822012-09-05 15:24:24 -04001531}
1532
1533string TWPartition::Backup_Method_By_Name() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001534 if (Backup_Method == NONE)
1535 return "none";
1536 else if (Backup_Method == FILES)
1537 return "files";
1538 else if (Backup_Method == DD)
1539 return "dd";
1540 else if (Backup_Method == FLASH_UTILS)
1541 return "flash_utils";
1542 else
1543 return "undefined";
1544 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -04001545}
1546
1547bool TWPartition::Decrypt(string Password) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001548 LOGINFO("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -04001549 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -04001550 return 1;
1551}
1552
1553bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001554 bool Save_Data_Media = Has_Data_Media;
1555
1556 if (!UnMount(true))
1557 return false;
1558
Dees_Troy38bd7602012-09-14 13:33:53 -04001559 Has_Data_Media = false;
Dees_Troy74fb2e92013-04-15 14:35:47 +00001560 Decrypted_Block_Device = "";
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001561#ifdef TW_INCLUDE_CRYPTO
1562 if (Is_Decrypted) {
1563 if (!UnMount(true))
1564 return false;
Matt Mower2b18a532015-02-20 16:58:05 -06001565 if (delete_crypto_blk_dev((char*)("userdata")) != 0) {
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001566 LOGERR("Error deleting crypto block device, continuing anyway.\n");
1567 }
1568 }
1569#endif
Dees_Troy74fb2e92013-04-15 14:35:47 +00001570 Is_Decrypted = false;
1571 Is_Encrypted = false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001572 Find_Actual_Block_Device();
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001573 if (Crypto_Key_Location == "footer") {
1574 int newlen, fd;
1575 if (Length != 0) {
1576 newlen = Length;
1577 if (newlen < 0)
1578 newlen = newlen * -1;
1579 } else {
1580 newlen = CRYPT_FOOTER_OFFSET;
1581 }
1582 if ((fd = open(Actual_Block_Device.c_str(), O_RDWR)) < 0) {
1583 gui_print_color("warning", "Unable to open '%s' to wipe crypto key\n", Actual_Block_Device.c_str());
1584 } else {
1585 unsigned int block_count;
1586 if ((ioctl(fd, BLKGETSIZE, &block_count)) == -1) {
1587 gui_print_color("warning", "Unable to get block size for wiping crypto footer.\n");
1588 } else {
1589 off64_t offset = ((off64_t)block_count * 512) - newlen;
1590 if (lseek64(fd, offset, SEEK_SET) == -1) {
1591 gui_print_color("warning", "Unable to lseek64 for wiping crypto footer.\n");
1592 } else {
1593 void* buffer = malloc(newlen);
1594 if (!buffer) {
1595 gui_print_color("warning", "Failed to malloc for wiping crypto footer.\n");
1596 } else {
1597 memset(buffer, 0, newlen);
1598 int ret = write(fd, buffer, newlen);
1599 if (ret != newlen) {
1600 gui_print_color("warning", "Failed to wipe crypto footer.\n");
1601 } else {
1602 LOGINFO("Successfully wiped crypto footer.\n");
1603 }
Matt Mower13a8f0b2015-09-26 15:40:03 -05001604 free(buffer);
Ethan Yonkerbc85b632015-08-09 12:48:14 -05001605 }
1606 }
1607 }
1608 close(fd);
1609 }
1610 } else {
1611 string Command = "flash_image " + Crypto_Key_Location + " /dev/zero";
1612 TWFunc::Exec_Cmd(Command);
1613 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001614 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001615 Has_Data_Media = Save_Data_Media;
1616 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
1617 Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001618 if (Mount(false))
1619 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001620 }
Ethan Yonkerd79d9bc2014-12-20 15:38:29 -06001621 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
Ethan Yonker83e82572014-04-04 10:59:28 -05001622#ifndef TW_OEM_BUILD
Ethan Yonker74db1572015-10-28 12:44:49 -05001623 gui_msg("format_data_msg=You may need to reboot recovery to be able to use /data again.");
Ethan Yonker83e82572014-04-04 10:59:28 -05001624#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001625 return true;
1626 } else {
1627 Has_Data_Media = Save_Data_Media;
Ethan Yonker74db1572015-10-28 12:44:49 -05001628 gui_err("format_data_err=Unable to format to remove encryption.");
Ethan Yonker726a0202014-12-16 20:01:38 -06001629 if (Has_Data_Media && Mount(false))
1630 PartitionManager.Add_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001631 return false;
1632 }
1633 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001634}
1635
1636void TWPartition::Check_FS_Type() {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001637 const char* type;
1638 blkid_probe pr;
Dees_Troy5bf43922012-09-07 16:07:55 -04001639
Dees_Troy68cab492012-12-12 19:29:35 +00001640 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1641 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001642
Dees_Troy38bd7602012-09-14 13:33:53 -04001643 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001644 if (!Is_Present)
1645 return;
Dees_Troy51127312012-09-08 13:08:49 -04001646
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001647 pr = blkid_new_probe_from_filename(Actual_Block_Device.c_str());
1648 if (blkid_do_fullprobe(pr)) {
1649 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001650 LOGINFO("Can't probe device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001651 return;
Dees_Troy5bf43922012-09-07 16:07:55 -04001652 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001653
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05001654 if (blkid_probe_lookup_value(pr, "TYPE", &type, NULL) < 0) {
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001655 blkid_free_probe(pr);
Dees_Troy2673cec2013-04-02 20:22:16 +00001656 LOGINFO("can't find filesystem on device %s\n", Actual_Block_Device.c_str());
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001657 return;
1658 }
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001659
bigbiff bigbiffe60683a2013-02-22 20:55:50 -05001660 Current_File_System = type;
Vojtech Bocek4d4b3362013-06-24 22:46:13 +02001661 blkid_free_probe(pr);
Dees_Troy51a0e822012-09-05 15:24:24 -04001662}
1663
Gary Peck43acadf2012-11-21 21:19:01 -08001664bool TWPartition::Wipe_EXT23(string File_System) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001665 if (!UnMount(true))
1666 return false;
1667
Dees_Troy43d8b002012-09-17 16:00:01 -04001668 if (TWFunc::Path_Exists("/sbin/mke2fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001669 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001670
Greg Wallace4b44fef2015-12-29 15:33:24 -05001671 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mke2fs"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001672 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001673 command = "mke2fs -t " + File_System + " -m 0 " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001674 LOGINFO("mke2fs command: %s\n", command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001675 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001676 Current_File_System = File_System;
Dees_Troye58d5262012-09-21 12:27:57 -04001677 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001678 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04001679 return true;
1680 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001681 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001682 return false;
1683 }
1684 } else
1685 return Wipe_RMRF();
1686
1687 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001688}
1689
1690bool TWPartition::Wipe_EXT4() {
Ethan Yonker25f20c12014-10-14 09:04:43 -05001691 Find_Actual_Block_Device();
1692 if (!Is_Present) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001693 LOGINFO("Block device not present, cannot wipe %s.\n", Display_Name.c_str());
1694 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Ethan Yonker25f20c12014-10-14 09:04:43 -05001695 return false;
1696 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001697 if (!UnMount(true))
1698 return false;
1699
Dees_Troyb3265ab2013-08-30 02:59:14 +00001700#if defined(HAVE_SELINUX) && defined(USE_EXT4)
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001701 int ret;
1702 char *secontext = NULL;
1703
Greg Wallace4b44fef2015-12-29 15:33:24 -05001704 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001705
Dees Troy99c8dbf2014-03-10 16:53:58 +00001706 if (!selinux_handle || selabel_lookup(selinux_handle, &secontext, Mount_Point.c_str(), S_IFDIR) < 0) {
Ethan Yonkerf27497f2014-02-09 11:48:33 -06001707 LOGINFO("Cannot lookup security context for '%s'\n", Mount_Point.c_str());
1708 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), NULL);
1709 } else {
1710 ret = make_ext4fs(Actual_Block_Device.c_str(), Length, Mount_Point.c_str(), selinux_handle);
1711 }
1712 if (ret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001713 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troya95f55c2013-08-17 13:14:43 +00001714 return false;
1715 } else {
bigbiff bigbiffc49d7062013-10-11 20:28:00 -04001716 string sedir = Mount_Point + "/lost+found";
1717 PartitionManager.Mount_By_Path(sedir.c_str(), true);
1718 rmdir(sedir.c_str());
1719 mkdir(sedir.c_str(), S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP);
Dees_Troya95f55c2013-08-17 13:14:43 +00001720 return true;
1721 }
1722#else
Dees_Troy43d8b002012-09-17 16:00:01 -04001723 if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
Vojtech Bocek05534202013-09-11 08:11:56 +02001724 string Command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001725
Greg Wallace4b44fef2015-12-29 15:33:24 -05001726 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("make_ext4fs"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001727 Find_Actual_Block_Device();
1728 Command = "make_ext4fs";
1729 if (!Is_Decrypted && Length != 0) {
1730 // Only use length if we're not decrypted
1731 char len[32];
1732 sprintf(len, "%i", Length);
1733 Command += " -l ";
1734 Command += len;
1735 }
Dees_Troy5295d582013-09-06 15:51:08 +00001736 if (TWFunc::Path_Exists("/file_contexts")) {
1737 Command += " -S /file_contexts";
1738 }
1739 Command += " -a " + Mount_Point + " " + Actual_Block_Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001740 LOGINFO("make_ext4fs command: %s\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001741 if (TWFunc::Exec_Cmd(Command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001742 Current_File_System = "ext4";
Dees_Troye58d5262012-09-21 12:27:57 -04001743 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001744 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04001745 return true;
1746 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001747 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001748 return false;
1749 }
1750 } else
Gary Peck43acadf2012-11-21 21:19:01 -08001751 return Wipe_EXT23("ext4");
Dees_Troya95f55c2013-08-17 13:14:43 +00001752#endif
Dees_Troy38bd7602012-09-14 13:33:53 -04001753 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001754}
1755
1756bool TWPartition::Wipe_FAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001757 string command;
Dees_Troy38bd7602012-09-14 13:33:53 -04001758
Matt Mower18794c82015-11-11 16:22:45 -06001759 if (TWFunc::Path_Exists("/sbin/mkfs.fat")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001760 if (!UnMount(true))
1761 return false;
1762
Greg Wallace4b44fef2015-12-29 15:33:24 -05001763 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.fat"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001764 Find_Actual_Block_Device();
Matt Mower18794c82015-11-11 16:22:45 -06001765 command = "mkfs.fat " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001766 if (TWFunc::Exec_Cmd(command) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001767 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04001768 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001769 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -04001770 return true;
1771 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001772 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troy38bd7602012-09-14 13:33:53 -04001773 return false;
1774 }
1775 return true;
1776 }
1777 else
1778 return Wipe_RMRF();
1779
1780 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001781}
1782
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001783bool TWPartition::Wipe_EXFAT() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001784 string command;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001785
1786 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
1787 if (!UnMount(true))
1788 return false;
1789
Greg Wallace4b44fef2015-12-29 15:33:24 -05001790 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkexfatfs"));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001791 Find_Actual_Block_Device();
1792 command = "mkexfatfs " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001793 if (TWFunc::Exec_Cmd(command) == 0) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001794 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001795 gui_msg("done=Done.");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001796 return true;
1797 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001798 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001799 return false;
1800 }
1801 return true;
1802 }
1803 return false;
1804}
1805
Dees_Troy38bd7602012-09-14 13:33:53 -04001806bool TWPartition::Wipe_MTD() {
1807 if (!UnMount(true))
1808 return false;
1809
Greg Wallace4b44fef2015-12-29 15:33:24 -05001810 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("MTD"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001811
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001812 mtd_scan_partitions();
1813 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
1814 if (mtd == NULL) {
1815 LOGERR("No mtd partition named '%s'", MTD_Name.c_str());
1816 return false;
1817 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001818
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001819 MtdWriteContext* ctx = mtd_write_partition(mtd);
1820 if (ctx == NULL) {
1821 LOGERR("Can't write '%s', failed to format.", MTD_Name.c_str());
1822 return false;
1823 }
1824 if (mtd_erase_blocks(ctx, -1) == -1) {
1825 mtd_write_close(ctx);
1826 LOGERR("Failed to format '%s'", MTD_Name.c_str());
1827 return false;
1828 }
1829 if (mtd_write_close(ctx) != 0) {
1830 LOGERR("Failed to close '%s'", MTD_Name.c_str());
1831 return false;
1832 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001833 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04001834 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001835 gui_msg("done=Done.");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001836 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001837}
1838
1839bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001840 if (!Mount(true))
1841 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06001842 // This is the only wipe that leaves the partition mounted, so we
1843 // must manually remove the partition from MTP if it is a storage
1844 // partition.
1845 if (Is_Storage)
1846 PartitionManager.Remove_MTP_Storage(MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001847
Ethan Yonker74db1572015-10-28 12:44:49 -05001848 gui_msg(Msg("remove_all=Removing all files under '{1}'")(Mount_Point));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001849 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04001850 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001851 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001852}
1853
Dees_Troye5017042013-08-29 16:38:55 +00001854bool TWPartition::Wipe_F2FS() {
Vojtech Bocek05534202013-09-11 08:11:56 +02001855 string command;
Dees_Troye5017042013-08-29 16:38:55 +00001856
1857 if (TWFunc::Path_Exists("/sbin/mkfs.f2fs")) {
1858 if (!UnMount(true))
1859 return false;
1860
Greg Wallace4b44fef2015-12-29 15:33:24 -05001861 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)("mkfs.f2fs"));
Dees_Troye5017042013-08-29 16:38:55 +00001862 Find_Actual_Block_Device();
dhacker29a3fa75f2015-01-17 19:42:33 -05001863 command = "mkfs.f2fs -t 1";
1864 if (!Is_Decrypted && Length != 0) {
1865 // Only use length if we're not decrypted
1866 char len[32];
1867 int mod_length = Length;
1868 if (Length < 0)
1869 mod_length *= -1;
1870 sprintf(len, "%i", mod_length);
1871 command += " -r ";
1872 command += len;
1873 }
1874 command += " " + Actual_Block_Device;
Vojtech Bocek05534202013-09-11 08:11:56 +02001875 if (TWFunc::Exec_Cmd(command) == 0) {
Dees_Troye5017042013-08-29 16:38:55 +00001876 Recreate_AndSec_Folder();
Ethan Yonker74db1572015-10-28 12:44:49 -05001877 gui_msg("done=Done.");
Dees_Troye5017042013-08-29 16:38:55 +00001878 return true;
1879 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001880 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
Dees_Troye5017042013-08-29 16:38:55 +00001881 return false;
1882 }
1883 return true;
1884 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001885 LOGINFO("mkfs.f2fs binary not found, using rm -rf to wipe.\n");
Dees_Troye5017042013-08-29 16:38:55 +00001886 return Wipe_RMRF();
1887 }
1888 return false;
1889}
1890
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001891bool TWPartition::Wipe_NTFS() {
1892 string command;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001893 string Ntfsmake_Binary;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001894
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001895 if (TWFunc::Path_Exists("/sbin/mkntfs"))
1896 Ntfsmake_Binary = "mkntfs";
1897 else if (TWFunc::Path_Exists("/sbin/mkfs.ntfs"))
1898 Ntfsmake_Binary = "mkfs.ntfs";
1899 else
1900 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001901
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001902 if (!UnMount(true))
1903 return false;
1904
Greg Wallace4b44fef2015-12-29 15:33:24 -05001905 gui_msg(Msg("formatting_using=Formatting {1} using {2}...")(Display_Name)(Ntfsmake_Binary));
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001906 Find_Actual_Block_Device();
1907 command = "/sbin/" + Ntfsmake_Binary + " " + Actual_Block_Device;
1908 if (TWFunc::Exec_Cmd(command) == 0) {
1909 Recreate_AndSec_Folder();
1910 gui_msg("done=Done.");
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001911 return true;
Greg Wallaceb39e6c62015-12-29 00:55:26 -05001912 } else {
1913 gui_msg(Msg(msg::kError, "unable_to_wipe=Unable to wipe {1}.")(Display_Name));
1914 return false;
Ethan Yonkerb81d9052015-07-09 13:20:53 -05001915 }
1916 return false;
1917}
1918
Dees_Troy51a0e822012-09-05 15:24:24 -04001919bool TWPartition::Wipe_Data_Without_Wiping_Media() {
Ethan Yonker83e82572014-04-04 10:59:28 -05001920#ifdef TW_OEM_BUILD
1921 // In an OEM Build we want to do a full format
1922 return Wipe_Encryption();
1923#else
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001924 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04001925
1926 // This handles wiping data on devices with "sdcard" in /data/media
1927 if (!Mount(true))
1928 return false;
1929
Ethan Yonker74db1572015-10-28 12:44:49 -05001930 gui_msg("wiping_data=Wiping data without wiping /data/media ...");
Dees_Troy38bd7602012-09-14 13:33:53 -04001931
1932 DIR* d;
1933 d = opendir("/data");
Dees_Troy16b74352012-11-14 22:27:31 +00001934 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001935 struct dirent* de;
1936 while ((de = readdir(d)) != NULL) {
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05001937 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
Dees_Troy16b74352012-11-14 22:27:31 +00001938 // The media folder is the "internal sdcard"
1939 // The .layout_version file is responsible for determining whether 4.2 decides up upgrade
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001940 // the media folder for multi-user.
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001941 //TODO: convert this to use twrpDU.cpp
Dees_Troy16b74352012-11-14 22:27:31 +00001942 if (strcmp(de->d_name, "media") == 0 || strcmp(de->d_name, ".layout_version") == 0) continue;
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001943
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001944 dir = "/data/";
1945 dir.append(de->d_name);
Dees_Troyce675462013-01-09 19:48:21 +00001946 if (de->d_type == DT_DIR) {
1947 TWFunc::removeDir(dir, false);
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05001948 } 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 +00001949 if (!unlink(dir.c_str()))
Dees_Troy2673cec2013-04-02 20:22:16 +00001950 LOGINFO("Unable to unlink '%s'\n", dir.c_str());
Dees_Troyce675462013-01-09 19:48:21 +00001951 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001952 }
1953 closedir(d);
bigbiff bigbiffc7360dd2014-01-25 15:02:57 -05001954
Ethan Yonker74db1572015-10-28 12:44:49 -05001955 gui_msg("done=Done.");
Dees_Troy16b74352012-11-14 22:27:31 +00001956 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001957 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001958 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Mount_Point)(strerror(errno)));
Dees_Troy16b74352012-11-14 22:27:31 +00001959 return false;
Ethan Yonker83e82572014-04-04 10:59:28 -05001960#endif // ifdef TW_OEM_BUILD
Dees_Troy51a0e822012-09-05 15:24:24 -04001961}
1962
bigbiff7abc5fe2015-01-17 16:53:12 -05001963bool 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 -04001964 char back_name[255], split_index[5];
1965 string Full_FileName, Split_FileName, Tar_Args, Command;
Dees_Troy83bd4832013-05-04 12:39:56 +00001966 int use_compression, use_encryption = 0, index, backup_count;
Dees_Troy4a2a1262012-09-18 09:33:47 -04001967 struct stat st;
Dees_Troy7c2dec82012-09-26 09:49:14 -04001968 unsigned long long total_bsize = 0, file_size;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001969 twrpTar tar;
1970 vector <string> files;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -05001971
Dees_Troy43d8b002012-09-17 16:00:01 -04001972 if (!Mount(true))
1973 return false;
1974
Dees_Troya13d74f2013-03-24 08:54:55 -05001975 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Backup_Display_Name, "Backing Up");
Ethan Yonker74db1572015-10-28 12:44:49 -05001976 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04001977
1978 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy83bd4832013-05-04 12:39:56 +00001979 tar.use_compression = use_compression;
Matt Mowerbb81e5d2014-03-20 18:05:41 -05001980
Dees_Troy83bd4832013-05-04 12:39:56 +00001981#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
1982 DataManager::GetValue("tw_encrypt_backup", use_encryption);
1983 if (use_encryption && Can_Encrypt_Backup) {
1984 tar.use_encryption = use_encryption;
1985 if (Use_Userdata_Encryption)
1986 tar.userdata_encryption = use_encryption;
Ethan Yonker87af5632014-02-10 11:56:35 -06001987 string Password;
1988 DataManager::GetValue("tw_backup_password", Password);
1989 tar.setpassword(Password);
Dees_Troy83bd4832013-05-04 12:39:56 +00001990 } else {
1991 use_encryption = false;
1992 }
1993#endif
Dees_Troy43d8b002012-09-17 16:00:01 -04001994
1995 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1996 Backup_FileName = back_name;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001997 Full_FileName = backup_folder + "/" + Backup_FileName;
Dees_Troy83bd4832013-05-04 12:39:56 +00001998 tar.has_data_media = Has_Data_Media;
Dees Troye0a433a2013-12-02 04:10:37 +00001999 Full_FileName = backup_folder + "/" + Backup_FileName;
2000 tar.setdir(Backup_Path);
2001 tar.setfn(Full_FileName);
2002 tar.setsize(Backup_Size);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002003 tar.partition_name = Backup_Name;
2004 tar.backup_folder = backup_folder;
bigbiff7abc5fe2015-01-17 16:53:12 -05002005 if (tar.createTarFork(overall_size, other_backups_size, tar_fork_pid) != 0)
Dees Troye0a433a2013-12-02 04:10:37 +00002006 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002007 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002008}
2009
2010bool TWPartition::Backup_DD(string backup_folder) {
codelover352b75e2015-03-29 02:44:07 +08002011 char back_name[255], block_size[32], dd_count[32];
2012 string Full_FileName, Command, DD_BS, DD_COUNT;
Dees_Troy43d8b002012-09-17 16:00:01 -04002013 int use_compression;
codelover352b75e2015-03-29 02:44:07 +08002014 unsigned long long DD_Block_Size, DD_Count;
Dees_Troy43d8b002012-09-17 16:00:01 -04002015
codelover352b75e2015-03-29 02:44:07 +08002016 DD_Block_Size = 16 * 1024 * 1024;
2017 while (Backup_Size % DD_Block_Size != 0) DD_Block_Size >>= 1;
2018
2019 DD_Count = Backup_Size / DD_Block_Size;
2020
2021 sprintf(dd_count, "%llu", DD_Count);
2022 DD_COUNT = dd_count;
2023
2024 sprintf(block_size, "%llu", DD_Block_Size);
2025 DD_BS = block_size;
igoriok87e3d932013-01-31 21:03:53 +02002026
Ethan Yonker74db1572015-10-28 12:44:49 -05002027 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2028 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002029
2030 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
2031 Backup_FileName = back_name;
2032
2033 Full_FileName = backup_folder + "/" + Backup_FileName;
2034
codelover352b75e2015-03-29 02:44:07 +08002035 Command = "dd if=" + Actual_Block_Device + " of='" + Full_FileName + "'" + " bs=" + DD_BS + " count=" + DD_COUNT;
Dees_Troy2673cec2013-04-02 20:22:16 +00002036 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002037 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002038 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troyc154ac22012-10-12 15:36:47 -04002039 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002040 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '{1}' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002041 return false;
2042 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002043 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002044}
2045
2046bool TWPartition::Backup_Dump_Image(string backup_folder) {
Dees_Troy43d8b002012-09-17 16:00:01 -04002047 char back_name[255];
Vojtech Bocek05534202013-09-11 08:11:56 +02002048 string Full_FileName, Command;
Dees_Troy43d8b002012-09-17 16:00:01 -04002049 int use_compression;
2050
Ethan Yonker74db1572015-10-28 12:44:49 -05002051 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, gui_parse_text("{@backing}"));
2052 gui_msg(Msg("backing_up=Backing up {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002053
2054 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
2055 Backup_FileName = back_name;
2056
2057 Full_FileName = backup_folder + "/" + Backup_FileName;
2058
2059 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
Dees_Troy2673cec2013-04-02 20:22:16 +00002060 LOGINFO("Backup command: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002061 TWFunc::Exec_Cmd(Command);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -06002062 tw_set_default_metadata(Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04002063 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
2064 // Actual size may not match backup size due to bad blocks on MTD devices so just check for 0 bytes
Ethan Yonker74db1572015-10-28 12:44:49 -05002065 gui_msg(Msg(msg::kError, "backup_size=Backup file size for '%s' is 0 bytes.")(Full_FileName));
Dees_Troy7c2dec82012-09-26 09:49:14 -04002066 return false;
2067 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002068 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002069}
2070
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002071unsigned long long TWPartition::Get_Restore_Size(string restore_folder) {
2072 InfoManager restore_info(restore_folder + "/" + Backup_Name + ".info");
2073 if (restore_info.LoadValues() == 0) {
2074 if (restore_info.GetValue("backup_size", Restore_Size) == 0) {
2075 LOGINFO("Read info file, restore size is %llu\n", Restore_Size);
2076 return Restore_Size;
2077 }
2078 }
2079 string Full_FileName, Restore_File_System = Get_Restore_File_System(restore_folder);
2080
2081 Full_FileName = restore_folder + "/" + Backup_FileName;
2082
2083 if (Is_Image(Restore_File_System)) {
2084 Restore_Size = TWFunc::Get_File_Size(Full_FileName);
2085 return Restore_Size;
2086 }
2087
2088 twrpTar tar;
2089 tar.setdir(Backup_Path);
2090 tar.setfn(Full_FileName);
2091 tar.backup_name = Backup_Name;
2092#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2093 string Password;
2094 DataManager::GetValue("tw_restore_password", Password);
2095 if (!Password.empty())
2096 tar.setpassword(Password);
2097#endif
2098 tar.partition_name = Backup_Name;
2099 tar.backup_folder = restore_folder;
2100 Restore_Size = tar.get_size();
2101 return Restore_Size;
2102}
2103
2104bool 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 -08002105 string Full_FileName, Command;
Dees_Troy4a2a1262012-09-18 09:33:47 -04002106 int index = 0;
2107 char split_index[5];
Dees Troy4159aed2014-02-28 17:24:43 +00002108 bool ret = false;
Dees_Troy43d8b002012-09-17 16:00:01 -04002109
Dees_Troye58d5262012-09-21 12:27:57 -04002110 if (Has_Android_Secure) {
Dees_Troye58d5262012-09-21 12:27:57 -04002111 if (!Wipe_AndSec())
2112 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08002113 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002114 gui_msg(Msg("wiping=Wiping {1}")(Backup_Display_Name));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002115 if (Has_Data_Media && Mount_Point == "/data" && Restore_File_System != Current_File_System) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002116 gui_msg(Msg(msg::kWarning, "datamedia_fs_restore=WARNING: This /data backup was made with {1} file system! The backup may not boot unless you change back to {1}.")(Restore_File_System));
Ethan Yonker5eac2222014-06-11 12:22:55 -05002117 if (!Wipe_Data_Without_Wiping_Media())
2118 return false;
2119 } else {
2120 if (!Wipe(Restore_File_System))
2121 return false;
2122 }
Dees_Troye58d5262012-09-21 12:27:57 -04002123 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002124 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restore}"));
2125 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002126
2127 if (!Mount(true))
2128 return false;
2129
Dees_Troy4a2a1262012-09-18 09:33:47 -04002130 Full_FileName = restore_folder + "/" + Backup_FileName;
Ethan Yonker87af5632014-02-10 11:56:35 -06002131 twrpTar tar;
2132 tar.setdir(Backup_Path);
2133 tar.setfn(Full_FileName);
2134 tar.backup_name = Backup_Name;
2135#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
2136 string Password;
2137 DataManager::GetValue("tw_restore_password", Password);
2138 if (!Password.empty())
2139 tar.setpassword(Password);
2140#endif
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002141 if (tar.extractTarFork(total_restore_size, already_restored_size) != 0)
Dees Troy4159aed2014-02-28 17:24:43 +00002142 ret = false;
2143 else
2144 ret = true;
2145#ifdef HAVE_CAPABILITIES
2146 // Restore capabilities to the run-as binary
2147 if (Mount_Point == "/system" && Mount(true) && TWFunc::Path_Exists("/system/bin/run-as")) {
2148 struct vfs_cap_data cap_data;
2149 uint64_t capabilities = (1 << CAP_SETUID) | (1 << CAP_SETGID);
2150
2151 memset(&cap_data, 0, sizeof(cap_data));
2152 cap_data.magic_etc = VFS_CAP_REVISION | VFS_CAP_FLAGS_EFFECTIVE;
2153 cap_data.data[0].permitted = (uint32_t) (capabilities & 0xffffffff);
2154 cap_data.data[0].inheritable = 0;
2155 cap_data.data[1].permitted = (uint32_t) (capabilities >> 32);
2156 cap_data.data[1].inheritable = 0;
2157 if (setxattr("/system/bin/run-as", XATTR_NAME_CAPS, &cap_data, sizeof(cap_data), 0) < 0) {
2158 LOGINFO("Failed to reset capabilities of /system/bin/run-as binary.\n");
2159 } else {
2160 LOGINFO("Reset capabilities of /system/bin/run-as binary successful.\n");
2161 }
2162 }
2163#endif
2164 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04002165}
2166
Ethan Yonker96af84a2015-01-05 14:58:36 -06002167bool TWPartition::Restore_Image(string restore_folder, const unsigned long long *total_restore_size, unsigned long long *already_restored_size, string Restore_File_System) {
2168 string Full_FileName;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002169 double display_percent, progress_percent;
2170 char size_progress[1024];
Dees_Troy43d8b002012-09-17 16:00:01 -04002171
Ethan Yonker74db1572015-10-28 12:44:49 -05002172 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Backup_Display_Name, gui_parse_text("{@restore}"));
2173 gui_msg(Msg("restoring=Restoring {1}...")(Backup_Display_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04002174 Full_FileName = restore_folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08002175
Ethan Yonker96af84a2015-01-05 14:58:36 -06002176 if (Restore_File_System == "emmc") {
2177 if (!Flash_Image_DD(Full_FileName))
2178 return false;
2179 } else if (Restore_File_System == "mtd" || Restore_File_System == "bml") {
2180 if (!Flash_Image_FI(Full_FileName))
2181 return false;
Gary Peck15e623d2012-11-21 21:07:58 -08002182 }
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05002183 display_percent = (double)(Restore_Size + *already_restored_size) / (double)(*total_restore_size) * 100;
2184 sprintf(size_progress, "%lluMB of %lluMB, %i%%", (Restore_Size + *already_restored_size) / 1048576, *total_restore_size / 1048576, (int)(display_percent));
2185 DataManager::SetValue("tw_size_progress", size_progress);
2186 progress_percent = (display_percent / 100);
2187 DataManager::SetProgress((float)(progress_percent));
2188 *already_restored_size += Restore_Size;
Dees_Troy43d8b002012-09-17 16:00:01 -04002189 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04002190}
Dees_Troy5bf43922012-09-07 16:07:55 -04002191
2192bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04002193 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04002194
Dees_Troyab10ee22012-09-21 14:27:30 -04002195 if (!Can_Be_Mounted && !Is_Encrypted)
Dees_Troy5bf43922012-09-07 16:07:55 -04002196 return false;
2197
Dees_Troy0550cfb2012-10-13 11:56:13 -04002198 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04002199 if (Removable || Is_Encrypted) {
2200 if (!Mount(false))
2201 return true;
2202 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04002203 return false;
Dees_Troy51127312012-09-08 13:08:49 -04002204
2205 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002206 if (!ret || Size == 0) {
2207 if (!Get_Size_Via_df(Display_Error)) {
2208 if (!Was_Already_Mounted)
2209 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04002210 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002211 }
2212 }
Dees_Troy51127312012-09-08 13:08:49 -04002213
Dees_Troy5bf43922012-09-07 16:07:55 -04002214 if (Has_Data_Media) {
2215 if (Mount(Display_Error)) {
Dees_Troy51127312012-09-08 13:08:49 -04002216 unsigned long long data_media_used, actual_data;
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002217 Used = du.Get_Folder_Size("/data");
2218 Backup_Size = Used;
2219 int bak = (int)(Used / 1048576LLU);
Dees_Troy51127312012-09-08 13:08:49 -04002220 int fre = (int)(Free / 1048576LLU);
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002221 LOGINFO("Data backup size is %iMB, free: %iMB.\n", bak, fre);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002222 } else {
2223 if (!Was_Already_Mounted)
2224 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002225 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002226 }
Dees_Troye58d5262012-09-21 12:27:57 -04002227 } else if (Has_Android_Secure) {
2228 if (Mount(Display_Error))
bigbiff bigbiff34684ff2013-12-01 21:03:45 -05002229 Backup_Size = du.Get_Folder_Size(Backup_Path);
Dees_Troy0550cfb2012-10-13 11:56:13 -04002230 else {
2231 if (!Was_Already_Mounted)
2232 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04002233 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04002234 }
Dees_Troy5bf43922012-09-07 16:07:55 -04002235 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04002236 if (!Was_Already_Mounted)
2237 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04002238 return true;
Dees_Troy51127312012-09-08 13:08:49 -04002239}
Dees_Troy38bd7602012-09-14 13:33:53 -04002240
2241void TWPartition::Find_Actual_Block_Device(void) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002242 if (Is_Decrypted && !Decrypted_Block_Device.empty()) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002243 Actual_Block_Device = Decrypted_Block_Device;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002244 if (TWFunc::Path_Exists(Decrypted_Block_Device))
Dees_Troy38bd7602012-09-14 13:33:53 -04002245 Is_Present = true;
Dees_Troy43d8b002012-09-17 16:00:01 -04002246 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04002247 Is_Present = true;
2248 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002249 return;
2250 }
2251 if (Is_Decrypted) {
Dees_Troy43d8b002012-09-17 16:00:01 -04002252 } else if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04002253 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04002254 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002255 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04002256 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002257 }
Dees_Troy38bd7602012-09-14 13:33:53 -04002258}
2259
2260void TWPartition::Recreate_Media_Folder(void) {
2261 string Command;
2262
2263 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002264 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")("/data/media"));
Dees_Troyb46a6842012-09-25 11:06:46 -04002265 } else if (!TWFunc::Path_Exists("/data/media")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002266 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy2673cec2013-04-02 20:22:16 +00002267 LOGINFO("Recreating /data/media folder.\n");
xiaolu9416f4f2015-06-04 08:22:23 +08002268 mkdir("/data/media", 0770);
2269 string Internal_path = DataManager::GetStrValue("tw_internal_path");
2270 if (!Internal_path.empty()) {
2271 LOGINFO("Recreating %s folder.\n", Internal_path.c_str());
2272 mkdir(Internal_path.c_str(), 0770);
2273 }
2274#ifdef TW_INTERNAL_STORAGE_PATH
2275 mkdir(EXPAND(TW_INTERNAL_STORAGE_PATH), 0770);
2276#endif
Ethan Yonker5ef301e2014-10-14 10:04:44 -05002277#ifdef HAVE_SELINUX
thata3d31fb2014-12-21 22:27:40 +01002278 // Afterwards, we will try to set the
2279 // default metadata that we were hopefully able to get during
2280 // early boot.
2281 tw_set_default_metadata("/data/media");
xiaolu9416f4f2015-06-04 08:22:23 +08002282 if (!Internal_path.empty())
2283 tw_set_default_metadata(Internal_path.c_str());
Ethan Yonker5ef301e2014-10-14 10:04:44 -05002284#endif
Ethan Yonker5eac2222014-06-11 12:22:55 -05002285 // Toggle mount to ensure that "internal sdcard" gets mounted
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002286 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Ethan Yonker5eac2222014-06-11 12:22:55 -05002287 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04002288 }
Dees_Troy43d8b002012-09-17 16:00:01 -04002289}
Dees_Troye58d5262012-09-21 12:27:57 -04002290
2291void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04002292 if (!Has_Android_Secure)
2293 return;
Dees_Troy2673cec2013-04-02 20:22:16 +00002294 LOGINFO("Creating %s: %s\n", Backup_Display_Name.c_str(), Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04002295 if (!Mount(true)) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002296 gui_msg(Msg(msg::kError, "recreate_folder_err=Unable to recreate {1} folder.")(Backup_Name));
Dees_Troye58d5262012-09-21 12:27:57 -04002297 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00002298 LOGINFO("Recreating %s folder.\n", Backup_Name.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002299 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -05002300 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05002301 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04002302 }
2303}
bigbiff7cb4c332014-11-26 20:36:07 -05002304
2305uint64_t TWPartition::Get_Max_FileSize() {
2306 uint64_t maxFileSize = 0;
2307 const uint64_t constGB = (uint64_t) 1024 * 1024 * 1024;
2308 const uint64_t constTB = (uint64_t) constGB * 1024;
2309 const uint64_t constPB = (uint64_t) constTB * 1024;
2310 const uint64_t constEB = (uint64_t) constPB * 1024;
bigbiff0c532032014-12-21 13:41:26 -05002311 if (Current_File_System == "ext4")
2312 maxFileSize = 16 * constTB; //16 TB
2313 else if (Current_File_System == "vfat")
2314 maxFileSize = 4 * constGB; //4 GB
2315 else if (Current_File_System == "ntfs")
2316 maxFileSize = 256 * constTB; //256 TB
2317 else if (Current_File_System == "exfat")
2318 maxFileSize = 16 * constPB; //16 PB
2319 else if (Current_File_System == "ext3")
2320 maxFileSize = 2 * constTB; //2 TB
2321 else if (Current_File_System == "f2fs")
2322 maxFileSize = 3.94 * constTB; //3.94 TB
bigbiff7cb4c332014-11-26 20:36:07 -05002323 else
2324 maxFileSize = 100000000L;
2325 return maxFileSize - 1;
2326}
2327
Ethan Yonker96af84a2015-01-05 14:58:36 -06002328bool TWPartition::Flash_Image(string Filename) {
2329 string Restore_File_System;
2330
2331 LOGINFO("Image filename is: %s\n", Filename.c_str());
2332
2333 if (Backup_Method == FILES) {
2334 LOGERR("Cannot flash images to file systems\n");
2335 return false;
2336 } else if (!Can_Flash_Img) {
2337 LOGERR("Cannot flash images to partitions %s\n", Display_Name.c_str());
2338 return false;
2339 } else {
2340 if (!Find_Partition_Size()) {
2341 LOGERR("Unable to find partition size for '%s'\n", Mount_Point.c_str());
2342 return false;
2343 }
2344 unsigned long long image_size = TWFunc::Get_File_Size(Filename);
2345 if (image_size > Size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002346 LOGINFO("Size (%llu bytes) of image '%s' is larger than target device '%s' (%llu bytes)\n",
Ethan Yonker96af84a2015-01-05 14:58:36 -06002347 image_size, Filename.c_str(), Actual_Block_Device.c_str(), Size);
Ethan Yonker74db1572015-10-28 12:44:49 -05002348 gui_err("img_size_err=Size of image is larger than target device");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002349 return false;
2350 }
2351 if (Backup_Method == DD)
2352 return Flash_Image_DD(Filename);
2353 else if (Backup_Method == FLASH_UTILS)
2354 return Flash_Image_FI(Filename);
2355 }
2356
2357 LOGERR("Unknown flash method for '%s'\n", Mount_Point.c_str());
2358 return false;
2359}
2360
2361bool TWPartition::Flash_Image_DD(string Filename) {
2362 string Command;
2363
Ethan Yonker74db1572015-10-28 12:44:49 -05002364 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
codelover352b75e2015-03-29 02:44:07 +08002365 Command = "dd bs=8388608 if='" + Filename + "' of=" + Actual_Block_Device;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002366 LOGINFO("Flash command: '%s'\n", Command.c_str());
2367 TWFunc::Exec_Cmd(Command);
2368 return true;
2369}
2370
2371bool TWPartition::Flash_Image_FI(string Filename) {
2372 string Command;
2373
Ethan Yonker74db1572015-10-28 12:44:49 -05002374 gui_msg(Msg("flashing=Flashing {1}...")(Display_Name));
Ethan Yonker96af84a2015-01-05 14:58:36 -06002375 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
2376 Command = "erase_image " + MTD_Name;
2377 LOGINFO("Erase command: '%s'\n", Command.c_str());
2378 TWFunc::Exec_Cmd(Command);
2379 Command = "flash_image " + MTD_Name + " '" + Filename + "'";
2380 LOGINFO("Flash command: '%s'\n", Command.c_str());
2381 TWFunc::Exec_Cmd(Command);
2382 return true;
2383}
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05002384
2385void TWPartition::Change_Mount_Read_Only(bool new_value) {
2386 Mount_Read_Only = new_value;
2387}
2388
2389int TWPartition::Check_Lifetime_Writes() {
2390 bool original_read_only = Mount_Read_Only;
2391 int ret = 1;
2392
2393 Mount_Read_Only = true;
2394 if (Mount(false)) {
2395 Find_Actual_Block_Device();
2396 string block = basename(Actual_Block_Device.c_str());
2397 string file = "/sys/fs/" + Current_File_System + "/" + block + "/lifetime_write_kbytes";
2398 string result;
2399 if (TWFunc::Path_Exists(file)) {
2400 if (TWFunc::read_file(file, result) != 0) {
2401 LOGINFO("Check_Lifetime_Writes of '%s' failed to read_file\n", file.c_str());
2402 } else {
2403 LOGINFO("Check_Lifetime_Writes result: '%s'\n", result.c_str());
2404 if (result == "0") {
2405 ret = 0;
2406 }
2407 }
2408 } else {
2409 LOGINFO("Check_Lifetime_Writes file does not exist '%s'\n", file.c_str());
2410 }
2411 UnMount(true);
2412 } else {
2413 LOGINFO("Check_Lifetime_Writes failed to mount '%s'\n", Mount_Point.c_str());
2414 }
2415 Mount_Read_Only = original_read_only;
2416 return ret;
2417}