blob: c532fa83050f44fe8e4c5e2b37a943852d182741 [file] [log] [blame]
Dees_Troy51a0e822012-09-05 15:24:24 -04001/* Partition class for TWRP
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15 * 02110-1301, USA.
16 *
17 * The code was written from scratch by Dees_Troy dees_troy at
18 * yahoo
19 *
20 * Copyright (c) 2012
21 */
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <sys/stat.h>
27#include <sys/vfs.h>
Dees_Troy5bf43922012-09-07 16:07:55 -040028#include <sys/mount.h>
Dees_Troy51a0e822012-09-05 15:24:24 -040029#include <unistd.h>
Dees_Troy51127312012-09-08 13:08:49 -040030#include <dirent.h>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050031#include <iostream>
32#include <sstream>
Dees_Troy51a0e822012-09-05 15:24:24 -040033
Dees_Troy657c3092012-09-10 20:32:10 -040034#ifdef TW_INCLUDE_CRYPTO
35 #include "cutils/properties.h"
36#endif
37
Dees_Troy51a0e822012-09-05 15:24:24 -040038#include "variables.h"
39#include "common.h"
40#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040041#include "data.hpp"
Dees_Troy43d8b002012-09-17 16:00:01 -040042#include "twrp-functions.hpp"
bigbiff bigbiff9c754052013-01-09 09:09:08 -050043#include "twrpTar.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040044extern "C" {
Dees_Troy38bd7602012-09-14 13:33:53 -040045 #include "mtdutils/mtdutils.h"
46 #include "mtdutils/mounts.h"
Dees_Troy85f44ed2013-01-09 18:42:36 +000047#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
48 #include "crypto/libcrypt_samsung/include/libcrypt_samsung.h"
49#endif
Dees_Troy5bf43922012-09-07 16:07:55 -040050}
Dees_Troy51a0e822012-09-05 15:24:24 -040051
bigbiff bigbiff9c754052013-01-09 09:09:08 -050052using namespace std;
53
Dees_Troy51a0e822012-09-05 15:24:24 -040054TWPartition::TWPartition(void) {
55 Can_Be_Mounted = false;
56 Can_Be_Wiped = false;
57 Wipe_During_Factory_Reset = false;
58 Wipe_Available_in_GUI = false;
59 Is_SubPartition = false;
Dees_Troy2691f9d2012-09-24 11:15:49 -040060 Has_SubPartition = false;
Dees_Troy51a0e822012-09-05 15:24:24 -040061 SubPartition_Of = "";
62 Symlink_Path = "";
63 Symlink_Mount_Point = "";
64 Mount_Point = "";
Dees_Troye58d5262012-09-21 12:27:57 -040065 Backup_Path = "";
Dees_Troy38bd7602012-09-14 13:33:53 -040066 Actual_Block_Device = "";
67 Primary_Block_Device = "";
Dees_Troy51a0e822012-09-05 15:24:24 -040068 Alternate_Block_Device = "";
69 Removable = false;
70 Is_Present = false;
71 Length = 0;
72 Size = 0;
73 Used = 0;
74 Free = 0;
75 Backup_Size = 0;
76 Can_Be_Encrypted = false;
77 Is_Encrypted = false;
78 Is_Decrypted = false;
79 Decrypted_Block_Device = "";
80 Display_Name = "";
81 Backup_Name = "";
Dees_Troy63c8df72012-09-10 14:02:05 -040082 Backup_FileName = "";
Dees_Troy38bd7602012-09-14 13:33:53 -040083 MTD_Name = "";
Dees_Troy51a0e822012-09-05 15:24:24 -040084 Backup_Method = NONE;
85 Has_Data_Media = false;
Dees_Troye58d5262012-09-21 12:27:57 -040086 Has_Android_Secure = false;
Dees_Troy51a0e822012-09-05 15:24:24 -040087 Is_Storage = false;
88 Storage_Path = "";
89 Current_File_System = "";
90 Fstab_File_System = "";
91 Format_Block_Size = 0;
Dees_Troy68cab492012-12-12 19:29:35 +000092 Ignore_Blkid = false;
Dees_Troy16c2b312013-01-15 16:51:18 +000093 Retain_Layout_Version = false;
Dees_Troy85f44ed2013-01-09 18:42:36 +000094#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
95 EcryptFS_Password = "";
96#endif
Dees_Troy51a0e822012-09-05 15:24:24 -040097}
98
99TWPartition::~TWPartition(void) {
100 // Do nothing
101}
102
Dees_Troy5bf43922012-09-07 16:07:55 -0400103bool TWPartition::Process_Fstab_Line(string Line, bool Display_Error) {
104 char full_line[MAX_FSTAB_LINE_LENGTH], item[MAX_FSTAB_LINE_LENGTH];
105 int line_len = Line.size(), index = 0, item_index = 0;
106 char* ptr;
Dees_Troy51127312012-09-08 13:08:49 -0400107 string Flags;
Dees_Troy5bf43922012-09-07 16:07:55 -0400108 strncpy(full_line, Line.c_str(), line_len);
109
Dees_Troy51127312012-09-08 13:08:49 -0400110 for (index = 0; index < line_len; index++) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400111 if (full_line[index] <= 32)
112 full_line[index] = '\0';
Dees_Troy5bf43922012-09-07 16:07:55 -0400113 }
Dees_Troy7c2dec82012-09-26 09:49:14 -0400114 Mount_Point = full_line;
115 LOGI("Processing '%s'\n", Mount_Point.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -0400116 Backup_Path = Mount_Point;
Dees_Troy5bf43922012-09-07 16:07:55 -0400117 index = Mount_Point.size();
118 while (index < line_len) {
119 while (index < line_len && full_line[index] == '\0')
120 index++;
121 if (index >= line_len)
122 continue;
123 ptr = full_line + index;
124 if (item_index == 0) {
125 // File System
126 Fstab_File_System = ptr;
127 Current_File_System = ptr;
128 item_index++;
129 } else if (item_index == 1) {
130 // Primary Block Device
Dees_Troy38bd7602012-09-14 13:33:53 -0400131 if (Fstab_File_System == "mtd" || Fstab_File_System == "yaffs2") {
Dees_Troy094207a2012-09-26 12:00:39 -0400132 MTD_Name = ptr;
133 Find_MTD_Block_Device(MTD_Name);
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400134 } else if (Fstab_File_System == "bml") {
135 if (Mount_Point == "/boot")
136 MTD_Name = "boot";
137 else if (Mount_Point == "/recovery")
138 MTD_Name = "recovery";
139 Primary_Block_Device = ptr;
140 if (*ptr != '/')
141 LOGE("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 -0400142 } else if (*ptr != '/') {
Dees_Troy5bf43922012-09-07 16:07:55 -0400143 if (Display_Error)
144 LOGE("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
145 else
146 LOGI("Invalid block device on '%s', '%s', %i\n", Line.c_str(), ptr, index);
147 return 0;
Dees_Troy38bd7602012-09-14 13:33:53 -0400148 } else {
149 Primary_Block_Device = ptr;
150 Find_Real_Block_Device(Primary_Block_Device, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400151 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400152 item_index++;
153 } else if (item_index > 1) {
154 if (*ptr == '/') {
155 // Alternate Block Device
156 Alternate_Block_Device = ptr;
157 Find_Real_Block_Device(Alternate_Block_Device, Display_Error);
158 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
159 // Partition length
160 ptr += 7;
161 Length = atoi(ptr);
Dees_Troy51127312012-09-08 13:08:49 -0400162 } else if (strlen(ptr) > 6 && strncmp(ptr, "flags=", 6) == 0) {
163 // Custom flags, save for later so that new values aren't overwritten by defaults
164 ptr += 6;
165 Flags = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000166 Process_Flags(Flags, Display_Error);
Dees_Troy38bd7602012-09-14 13:33:53 -0400167 } else if (strlen(ptr) == 4 && (strncmp(ptr, "NULL", 4) == 0 || strncmp(ptr, "null", 4) == 0 || strncmp(ptr, "null", 4) == 0)) {
168 // Do nothing
Dees_Troy5bf43922012-09-07 16:07:55 -0400169 } else {
170 // Unhandled data
Dees_Troyab10ee22012-09-21 14:27:30 -0400171 LOGI("Unhandled fstab information: '%s', %i, line: '%s'\n", ptr, index, Line.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400172 }
173 }
174 while (index < line_len && full_line[index] != '\0')
175 index++;
176 }
177
178 if (!Is_File_System(Fstab_File_System) && !Is_Image(Fstab_File_System)) {
179 if (Display_Error)
180 LOGE("Unknown File System: '%s'\n", Fstab_File_System.c_str());
181 else
182 LOGI("Unknown File System: '%s'\n", Fstab_File_System.c_str());
183 return 0;
184 } else if (Is_File_System(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400185 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400186 Setup_File_System(Display_Error);
187 if (Mount_Point == "/system") {
188 Display_Name = "System";
189 Wipe_Available_in_GUI = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400190 } else if (Mount_Point == "/data") {
191 Display_Name = "Data";
192 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400193 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400194#ifdef RECOVERY_SDCARD_ON_DATA
195 Has_Data_Media = true;
Dees_Troy51127312012-09-08 13:08:49 -0400196 Is_Storage = true;
197 Storage_Path = "/data/media";
Dees_Troy16b74352012-11-14 22:27:31 +0000198 Symlink_Path = Storage_Path;
Dees_Troy657c3092012-09-10 20:32:10 -0400199 if (strcmp(EXPAND(TW_EXTERNAL_STORAGE_PATH), "/sdcard") == 0) {
200 Make_Dir("/emmc", Display_Error);
Dees_Troy657c3092012-09-10 20:32:10 -0400201 Symlink_Mount_Point = "/emmc";
202 } else {
203 Make_Dir("/sdcard", Display_Error);
Dees_Troy657c3092012-09-10 20:32:10 -0400204 Symlink_Mount_Point = "/sdcard";
205 }
Dees_Troy16b74352012-11-14 22:27:31 +0000206 if (Mount(false) && TWFunc::Path_Exists("/data/media/0")) {
207 Storage_Path = "/data/media/0";
208 Symlink_Path = Storage_Path;
209 DataManager::SetValue(TW_INTERNAL_PATH, "/data/media/0");
210 UnMount(true);
211 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400212#endif
213#ifdef TW_INCLUDE_CRYPTO
214 Can_Be_Encrypted = true;
Dees_Troy657c3092012-09-10 20:32:10 -0400215 char crypto_blkdev[255];
216 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
217 if (strcmp(crypto_blkdev, "error") != 0) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400218 DataManager::SetValue(TW_DATA_BLK_DEVICE, Primary_Block_Device);
Dees_Troy657c3092012-09-10 20:32:10 -0400219 DataManager::SetValue(TW_IS_DECRYPTED, 1);
220 Is_Encrypted = true;
221 Is_Decrypted = true;
222 Decrypted_Block_Device = crypto_blkdev;
223 LOGI("Data already decrypted, new block device: '%s'\n", crypto_blkdev);
224 } else if (!Mount(false)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400225 Is_Encrypted = true;
226 Is_Decrypted = false;
Gary Peck82599a82012-11-21 16:23:12 -0800227 Can_Be_Mounted = false;
228 Current_File_System = "emmc";
229 Setup_Image(Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400230 DataManager::SetValue(TW_IS_ENCRYPTED, 1);
231 DataManager::SetValue(TW_CRYPTO_PASSWORD, "");
232 DataManager::SetValue("tw_crypto_display", "");
Gary Peck82599a82012-11-21 16:23:12 -0800233 } else {
234 // Filesystem is not encrypted and the mount
235 // succeeded, so get it back to the original
236 // unmounted state
237 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -0400238 }
Dees_Troy9b21af72012-10-01 15:51:46 -0400239 #ifdef RECOVERY_SDCARD_ON_DATA
240 if (!Is_Encrypted || (Is_Encrypted && Is_Decrypted))
241 Recreate_Media_Folder();
242 #endif
243#else
244 #ifdef RECOVERY_SDCARD_ON_DATA
245 Recreate_Media_Folder();
246 #endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400247#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400248 } else if (Mount_Point == "/cache") {
249 Display_Name = "Cache";
250 Wipe_Available_in_GUI = true;
Dees_Troy51127312012-09-08 13:08:49 -0400251 Wipe_During_Factory_Reset = true;
Dees_Troyce2fe772012-09-28 12:34:33 -0400252 if (Mount(false) && !TWFunc::Path_Exists("/cache/recovery/.")) {
Dees_Troyb46a6842012-09-25 11:06:46 -0400253 LOGI("Recreating /cache/recovery folder.\n");
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500254 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
255 return -1;
Dees_Troyb46a6842012-09-25 11:06:46 -0400256 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400257 } else if (Mount_Point == "/datadata") {
Dees_Troy51127312012-09-08 13:08:49 -0400258 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400259 Display_Name = "DataData";
260 Is_SubPartition = true;
261 SubPartition_Of = "/data";
Dees_Troy5bf43922012-09-07 16:07:55 -0400262 DataManager::SetValue(TW_HAS_DATADATA, 1);
263 } else if (Mount_Point == "/sd-ext") {
Dees_Troy51127312012-09-08 13:08:49 -0400264 Wipe_During_Factory_Reset = true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400265 Display_Name = "SD-Ext";
266 Wipe_Available_in_GUI = true;
Dees_Troyc51f1f92012-09-20 15:32:13 -0400267 Removable = true;
Dees_Troy2c50e182012-09-26 20:05:28 -0400268 } else if (Mount_Point == "/boot") {
269 Display_Name = "Boot";
270 DataManager::SetValue("tw_boot_is_mountable", 1);
Dees_Troy8170a922012-09-18 15:40:25 -0400271 }
272#ifdef TW_EXTERNAL_STORAGE_PATH
273 if (Mount_Point == EXPAND(TW_EXTERNAL_STORAGE_PATH)) {
274 Is_Storage = true;
275 Storage_Path = EXPAND(TW_EXTERNAL_STORAGE_PATH);
Dees_Troyc51f1f92012-09-20 15:32:13 -0400276 Removable = true;
Dees_Troy8170a922012-09-18 15:40:25 -0400277 }
278#else
279 if (Mount_Point == "/sdcard") {
280 Is_Storage = true;
281 Storage_Path = "/sdcard";
Dees_Troyc51f1f92012-09-20 15:32:13 -0400282 Removable = true;
Dees_Troye58d5262012-09-21 12:27:57 -0400283#ifndef RECOVERY_SDCARD_ON_DATA
284 Setup_AndSec();
Dees_Troy8e337f32012-10-13 22:07:49 -0400285 Mount_Storage_Retry();
Dees_Troye58d5262012-09-21 12:27:57 -0400286#endif
Dees_Troy8170a922012-09-18 15:40:25 -0400287 }
288#endif
289#ifdef TW_INTERNAL_STORAGE_PATH
290 if (Mount_Point == EXPAND(TW_INTERNAL_STORAGE_PATH)) {
291 Is_Storage = true;
292 Storage_Path = EXPAND(TW_INTERNAL_STORAGE_PATH);
Dees_Troye58d5262012-09-21 12:27:57 -0400293#ifndef RECOVERY_SDCARD_ON_DATA
294 Setup_AndSec();
Dees_Troy8e337f32012-10-13 22:07:49 -0400295 Mount_Storage_Retry();
Dees_Troye58d5262012-09-21 12:27:57 -0400296#endif
Dees_Troy8170a922012-09-18 15:40:25 -0400297 }
298#else
299 if (Mount_Point == "/emmc") {
300 Is_Storage = true;
301 Storage_Path = "/emmc";
Dees_Troye58d5262012-09-21 12:27:57 -0400302#ifndef RECOVERY_SDCARD_ON_DATA
303 Setup_AndSec();
Dees_Troy8e337f32012-10-13 22:07:49 -0400304 Mount_Storage_Retry();
Dees_Troye58d5262012-09-21 12:27:57 -0400305#endif
Dees_Troy8170a922012-09-18 15:40:25 -0400306 }
307#endif
Dees_Troy5bf43922012-09-07 16:07:55 -0400308 } else if (Is_Image(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400309 Find_Actual_Block_Device();
Dees_Troy5bf43922012-09-07 16:07:55 -0400310 Setup_Image(Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400311 }
312
Dees_Troy51127312012-09-08 13:08:49 -0400313 // Process any custom flags
314 if (Flags.size() > 0)
315 Process_Flags(Flags, Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -0400316 return true;
317}
318
319bool TWPartition::Process_Flags(string Flags, bool Display_Error) {
320 char flags[MAX_FSTAB_LINE_LENGTH];
321 int flags_len, index = 0;
322 char* ptr;
323
324 strcpy(flags, Flags.c_str());
325 flags_len = Flags.size();
326 for (index = 0; index < flags_len; index++) {
327 if (flags[index] == ';')
328 flags[index] = '\0';
329 }
330
331 index = 0;
332 while (index < flags_len) {
333 while (index < flags_len && flags[index] == '\0')
334 index++;
335 if (index >= flags_len)
336 continue;
337 ptr = flags + index;
338 if (strcmp(ptr, "removable") == 0) {
339 Removable = true;
340 } else if (strcmp(ptr, "storage") == 0) {
341 Is_Storage = true;
Dees_Troy63c8df72012-09-10 14:02:05 -0400342 } else if (strcmp(ptr, "canbewiped") == 0) {
343 Can_Be_Wiped = true;
344 } else if (strcmp(ptr, "wipeingui") == 0) {
345 Can_Be_Wiped = true;
346 Wipe_Available_in_GUI = true;
347 } else if (strcmp(ptr, "wipeduringfactoryreset") == 0) {
348 Can_Be_Wiped = true;
349 Wipe_Available_in_GUI = true;
350 Wipe_During_Factory_Reset = true;
Dees_Troy51127312012-09-08 13:08:49 -0400351 } else if (strlen(ptr) > 15 && strncmp(ptr, "subpartitionof=", 15) == 0) {
352 ptr += 13;
353 Is_SubPartition = true;
354 SubPartition_Of = ptr;
Dees_Troy68cab492012-12-12 19:29:35 +0000355 } else if (strcmp(ptr, "ignoreblkid") == 0) {
356 Ignore_Blkid = true;
Dees_Troy16c2b312013-01-15 16:51:18 +0000357 } else if (strcmp(ptr, "retainlayoutversion") == 0) {
358 Retain_Layout_Version = true;
Dees_Troy51127312012-09-08 13:08:49 -0400359 } else if (strlen(ptr) > 8 && strncmp(ptr, "symlink=", 8) == 0) {
360 ptr += 8;
361 Symlink_Path = ptr;
362 } else if (strlen(ptr) > 8 && strncmp(ptr, "display=", 8) == 0) {
363 ptr += 8;
364 Display_Name = ptr;
365 } else if (strlen(ptr) > 10 && strncmp(ptr, "blocksize=", 10) == 0) {
366 ptr += 10;
367 Format_Block_Size = atoi(ptr);
368 } else if (strlen(ptr) > 7 && strncmp(ptr, "length=", 7) == 0) {
369 ptr += 7;
370 Length = atoi(ptr);
371 } else {
372 if (Display_Error)
373 LOGE("Unhandled flag: '%s'\n", ptr);
374 else
375 LOGI("Unhandled flag: '%s'\n", ptr);
376 }
377 while (index < flags_len && flags[index] != '\0')
378 index++;
379 }
380 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400381}
382
Dees_Troy5bf43922012-09-07 16:07:55 -0400383bool TWPartition::Is_File_System(string File_System) {
384 if (File_System == "ext2" ||
Dees_Troy63c8df72012-09-10 14:02:05 -0400385 File_System == "ext3" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400386 File_System == "ext4" ||
387 File_System == "vfat" ||
388 File_System == "ntfs" ||
389 File_System == "yaffs2" ||
bigbiff bigbiff3e146522012-11-14 14:32:59 -0500390 File_System == "exfat" ||
Dees_Troy5bf43922012-09-07 16:07:55 -0400391 File_System == "auto")
392 return true;
393 else
394 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400395}
396
Dees_Troy5bf43922012-09-07 16:07:55 -0400397bool TWPartition::Is_Image(string File_System) {
Dees_Troy5fcd8f92012-10-16 12:22:05 -0400398 if (File_System == "emmc" || File_System == "mtd" || File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400399 return true;
400 else
401 return false;
402}
403
Dees_Troy51127312012-09-08 13:08:49 -0400404bool TWPartition::Make_Dir(string Path, bool Display_Error) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400405 if (!TWFunc::Path_Exists(Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400406 if (mkdir(Path.c_str(), 0777) == -1) {
407 if (Display_Error)
408 LOGE("Can not create '%s' folder.\n", Path.c_str());
409 else
410 LOGI("Can not create '%s' folder.\n", Path.c_str());
411 return false;
412 } else {
413 LOGI("Created '%s' folder.\n", Path.c_str());
414 return true;
415 }
416 }
417 return true;
418}
419
Dees_Troy5bf43922012-09-07 16:07:55 -0400420void TWPartition::Setup_File_System(bool Display_Error) {
421 struct statfs st;
422
423 Can_Be_Mounted = true;
424 Can_Be_Wiped = true;
425
Dees_Troy5bf43922012-09-07 16:07:55 -0400426 // Make the mount point folder if it doesn't exist
Dees_Troy51127312012-09-08 13:08:49 -0400427 Make_Dir(Mount_Point, Display_Error);
Dees_Troy5bf43922012-09-07 16:07:55 -0400428 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
429 Backup_Name = Display_Name;
430 Backup_Method = FILES;
431}
432
433void TWPartition::Setup_Image(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400434 Display_Name = Mount_Point.substr(1, Mount_Point.size() - 1);
435 Backup_Name = Display_Name;
Gary Peck82599a82012-11-21 16:23:12 -0800436 if (Current_File_System == "emmc")
Dees_Troy5bf43922012-09-07 16:07:55 -0400437 Backup_Method = DD;
Gary Peck82599a82012-11-21 16:23:12 -0800438 else if (Current_File_System == "mtd" || Current_File_System == "bml")
Dees_Troy5bf43922012-09-07 16:07:55 -0400439 Backup_Method = FLASH_UTILS;
440 else
Gary Peck82599a82012-11-21 16:23:12 -0800441 LOGI("Unhandled file system '%s' on image '%s'\n", Current_File_System.c_str(), Display_Name.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400442 if (Find_Partition_Size()) {
443 Used = Size;
444 Backup_Size = Size;
Dees_Troy51a0e822012-09-05 15:24:24 -0400445 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400446 if (Display_Error)
Dees_Troy38bd7602012-09-14 13:33:53 -0400447 LOGE("Unable to find parition size for '%s'\n", Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400448 else
Dees_Troy38bd7602012-09-14 13:33:53 -0400449 LOGI("Unable to find parition size for '%s'\n", Mount_Point.c_str());
Dees_Troy51a0e822012-09-05 15:24:24 -0400450 }
451}
452
Dees_Troye58d5262012-09-21 12:27:57 -0400453void TWPartition::Setup_AndSec(void) {
454 Backup_Name = "and-sec";
455 Has_Android_Secure = true;
456 Symlink_Path = Mount_Point + "/.android_secure";
457 Symlink_Mount_Point = "/and-sec";
458 Backup_Path = Symlink_Mount_Point;
459 Make_Dir("/and-sec", true);
460 Recreate_AndSec_Folder();
461}
462
Dees_Troy5bf43922012-09-07 16:07:55 -0400463void TWPartition::Find_Real_Block_Device(string& Block, bool Display_Error) {
464 char device[512], realDevice[512];
465
466 strcpy(device, Block.c_str());
467 memset(realDevice, 0, sizeof(realDevice));
468 while (readlink(device, realDevice, sizeof(realDevice)) > 0)
469 {
470 strcpy(device, realDevice);
471 memset(realDevice, 0, sizeof(realDevice));
472 }
473
474 if (device[0] != '/') {
475 if (Display_Error)
476 LOGE("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
477 else
478 LOGI("Invalid symlink path '%s' found on block device '%s'\n", device, Block.c_str());
479 return;
Dees_Troy51a0e822012-09-05 15:24:24 -0400480 } else {
Dees_Troy5bf43922012-09-07 16:07:55 -0400481 Block = device;
482 return;
483 }
484}
485
Dees_Troy8e337f32012-10-13 22:07:49 -0400486void TWPartition::Mount_Storage_Retry(void) {
487 // On some devices, storage doesn't want to mount right away, retry and sleep
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500488 if (!Mount(true)) {
Dees_Troy8e337f32012-10-13 22:07:49 -0400489 int retry_count = 5;
490 while (retry_count > 0 && !Mount(false)) {
491 usleep(500000);
492 retry_count--;
493 }
494 Mount(true);
495 }
496}
497
Dees_Troy38bd7602012-09-14 13:33:53 -0400498bool TWPartition::Find_MTD_Block_Device(string MTD_Name) {
499 FILE *fp = NULL;
500 char line[255];
501
502 fp = fopen("/proc/mtd", "rt");
503 if (fp == NULL) {
504 LOGE("Device does not support /proc/mtd\n");
505 return false;
506 }
507
508 while (fgets(line, sizeof(line), fp) != NULL)
509 {
510 char device[32], label[32];
511 unsigned long size = 0;
512 char* fstype = NULL;
513 int deviceId;
514
515 sscanf(line, "%s %lx %*s %*c%s", device, &size, label);
516
517 // Skip header and blank lines
518 if ((strcmp(device, "dev:") == 0) || (strlen(line) < 8))
519 continue;
520
521 // Strip off the trailing " from the label
522 label[strlen(label)-1] = '\0';
523
524 if (strcmp(label, MTD_Name.c_str()) == 0) {
525 // We found our device
526 // Strip off the trailing : from the device
527 device[strlen(device)-1] = '\0';
528 if (sscanf(device,"mtd%d", &deviceId) == 1) {
529 sprintf(device, "/dev/block/mtdblock%d", deviceId);
530 Primary_Block_Device = device;
531 }
532 }
533 }
534 fclose(fp);
535
536 return false;
537}
538
Dees_Troy51127312012-09-08 13:08:49 -0400539bool TWPartition::Get_Size_Via_statfs(bool Display_Error) {
540 struct statfs st;
541 string Local_Path = Mount_Point + "/.";
542
543 if (!Mount(Display_Error))
544 return false;
545
546 if (statfs(Local_Path.c_str(), &st) != 0) {
547 if (!Removable) {
548 if (Display_Error)
549 LOGE("Unable to statfs '%s'\n", Local_Path.c_str());
550 else
551 LOGI("Unable to statfs '%s'\n", Local_Path.c_str());
552 }
553 return false;
554 }
555 Size = (st.f_blocks * st.f_bsize);
556 Used = ((st.f_blocks - st.f_bfree) * st.f_bsize);
557 Free = (st.f_bfree * st.f_bsize);
558 Backup_Size = Used;
559 return true;
560}
561
562bool TWPartition::Get_Size_Via_df(bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400563 FILE* fp;
564 char command[255], line[512];
565 int include_block = 1;
566 unsigned int min_len;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500567 string result;
Dees_Troy5bf43922012-09-07 16:07:55 -0400568
569 if (!Mount(Display_Error))
570 return false;
571
Dees_Troy38bd7602012-09-14 13:33:53 -0400572 min_len = Actual_Block_Device.size() + 2;
Dees_Troy51127312012-09-08 13:08:49 -0400573 sprintf(command, "df %s > /tmp/dfoutput.txt", Mount_Point.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500574 TWFunc::Exec_Cmd(command, result);
Dees_Troy51127312012-09-08 13:08:49 -0400575 fp = fopen("/tmp/dfoutput.txt", "rt");
576 if (fp == NULL) {
577 LOGI("Unable to open /tmp/dfoutput.txt.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400578 return false;
Dees_Troy51127312012-09-08 13:08:49 -0400579 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400580
581 while (fgets(line, sizeof(line), fp) != NULL)
582 {
583 unsigned long blocks, used, available;
584 char device[64];
585 char tmpString[64];
586
587 if (strncmp(line, "Filesystem", 10) == 0)
588 continue;
589 if (strlen(line) < min_len) {
590 include_block = 0;
591 continue;
592 }
593 if (include_block) {
594 sscanf(line, "%s %lu %lu %lu", device, &blocks, &used, &available);
595 } else {
596 // The device block string is so long that the df information is on the next line
597 int space_count = 0;
Dees_Troye58d5262012-09-21 12:27:57 -0400598 sprintf(tmpString, "/dev/block/%s", Actual_Block_Device.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400599 while (tmpString[space_count] == 32)
600 space_count++;
601 sscanf(line + space_count, "%lu %lu %lu", &blocks, &used, &available);
602 }
603
604 // Adjust block size to byte size
605 Size = blocks * 1024ULL;
606 Used = used * 1024ULL;
607 Free = available * 1024ULL;
608 Backup_Size = Used;
609 }
610 fclose(fp);
611 return true;
612}
613
Dees_Troy5bf43922012-09-07 16:07:55 -0400614bool TWPartition::Find_Partition_Size(void) {
615 FILE* fp;
616 char line[512];
617 string tmpdevice;
618
619 // In this case, we'll first get the partitions we care about (with labels)
620 fp = fopen("/proc/partitions", "rt");
621 if (fp == NULL)
622 return false;
623
624 while (fgets(line, sizeof(line), fp) != NULL)
625 {
626 unsigned long major, minor, blocks;
627 char device[512];
628 char tmpString[64];
629
Dees_Troy63c8df72012-09-10 14:02:05 -0400630 if (strlen(line) < 7 || line[0] == 'm') continue;
Dees_Troy5bf43922012-09-07 16:07:55 -0400631 sscanf(line + 1, "%lu %lu %lu %s", &major, &minor, &blocks, device);
632
633 tmpdevice = "/dev/block/";
634 tmpdevice += device;
Dees_Troy38bd7602012-09-14 13:33:53 -0400635 if (tmpdevice == Primary_Block_Device || tmpdevice == Alternate_Block_Device) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400636 // Adjust block size to byte size
637 Size = blocks * 1024ULL;
638 fclose(fp);
639 return true;
640 }
641 }
642 fclose(fp);
643 return false;
644}
645
Dees_Troy5bf43922012-09-07 16:07:55 -0400646bool TWPartition::Is_Mounted(void) {
647 if (!Can_Be_Mounted)
648 return false;
649
650 struct stat st1, st2;
651 string test_path;
652
653 // Check to see if the mount point directory exists
654 test_path = Mount_Point + "/.";
655 if (stat(test_path.c_str(), &st1) != 0) return false;
656
657 // Check to see if the directory above the mount point exists
658 test_path = Mount_Point + "/../.";
659 if (stat(test_path.c_str(), &st2) != 0) return false;
660
661 // Compare the device IDs -- if they match then we're (probably) using tmpfs instead of an actual device
662 int ret = (st1.st_dev != st2.st_dev) ? true : false;
663
664 return ret;
665}
666
667bool TWPartition::Mount(bool Display_Error) {
668 if (Is_Mounted()) {
669 return true;
670 } else if (!Can_Be_Mounted) {
671 return false;
672 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400673
674 Find_Actual_Block_Device();
675
676 // Check the current file system before mounting
677 Check_FS_Type();
Dees_Troy22042032012-12-18 21:23:08 +0000678 if (Fstab_File_System == "yaffs2") {
679 // mount an MTD partition as a YAFFS2 filesystem.
680 mtd_scan_partitions();
681 const MtdPartition* partition;
682 partition = mtd_find_partition_by_name(MTD_Name.c_str());
683 if (partition == NULL) {
684 LOGE("Failed to find '%s' partition to mount at '%s'\n",
685 MTD_Name.c_str(), Mount_Point.c_str());
686 return false;
687 }
688 if (mtd_mount_partition(partition, Mount_Point.c_str(), Fstab_File_System.c_str(), 0)) {
689 if (Display_Error)
690 LOGE("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
691 else
692 LOGI("Failed to mount '%s' (MTD)\n", Mount_Point.c_str());
693 return false;
694 } else
695 return true;
Dees_Troy85f44ed2013-01-09 18:42:36 +0000696 } else if (Current_File_System == "exfat" && TWFunc::Path_Exists("/sbin/exfat-fuse")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500697 string cmd = "/sbin/exfat-fuse " + Actual_Block_Device + " " + Mount_Point;
Dees_Troy85f44ed2013-01-09 18:42:36 +0000698 LOGI("cmd: %s\n", cmd.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500699 string result;
700 if (TWFunc::Exec_Cmd(cmd, result) != 0)
701 return false;
Dees_Troy22042032012-12-18 21:23:08 +0000702 } else if (mount(Actual_Block_Device.c_str(), Mount_Point.c_str(), Current_File_System.c_str(), 0, NULL) != 0) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400703 if (Display_Error)
704 LOGE("Unable to mount '%s'\n", Mount_Point.c_str());
705 else
706 LOGI("Unable to mount '%s'\n", Mount_Point.c_str());
Dees_Troy9350b8d2012-09-27 12:38:38 -0400707 LOGI("Actual block device: '%s', current file system: '%s'\n", Actual_Block_Device.c_str(), Current_File_System.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -0400708 return false;
709 } else {
Dees_Troy85f44ed2013-01-09 18:42:36 +0000710#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
Dees_Troy999b39d2013-01-14 15:36:13 +0000711 string MetaEcfsFile = EXPAND(TW_EXTERNAL_STORAGE_PATH);
712 MetaEcfsFile += "/.MetaEcfsFile";
713 if (EcryptFS_Password.size() > 0 && PartitionManager.Mount_By_Path("/data", false) && TWFunc::Path_Exists(MetaEcfsFile)) {
Dees_Troy85f44ed2013-01-09 18:42:36 +0000714 if (mount_ecryptfs_drive(EcryptFS_Password.c_str(), Mount_Point.c_str(), Mount_Point.c_str(), 0) != 0) {
715 if (Display_Error)
716 LOGE("Unable to mount ecryptfs for '%s'\n", Mount_Point.c_str());
717 else
718 LOGI("Unable to mount ecryptfs for '%s'\n", Mount_Point.c_str());
719 } else {
720 LOGI("Successfully mounted ecryptfs for '%s'\n", Mount_Point.c_str());
721 }
722 }
723#endif
Dees_Troy38bd7602012-09-14 13:33:53 -0400724 if (Removable)
725 Update_Size(Display_Error);
726
727 if (!Symlink_Mount_Point.empty()) {
Dees_Troydc8bc1b2013-01-17 01:39:28 +0000728 string Command, Result;
729 Command = "mount '" + Symlink_Path + "' '" + Symlink_Mount_Point + "'";
730 TWFunc::Exec_Cmd(Command, Result);
Dees_Troy51127312012-09-08 13:08:49 -0400731 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400732 return true;
Dees_Troy5bf43922012-09-07 16:07:55 -0400733 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400734 return true;
735}
736
737bool TWPartition::UnMount(bool Display_Error) {
738 if (Is_Mounted()) {
739 int never_unmount_system;
740
741 DataManager::GetValue(TW_DONT_UNMOUNT_SYSTEM, never_unmount_system);
742 if (never_unmount_system == 1 && Mount_Point == "/system")
743 return true; // Never unmount system if you're not supposed to unmount it
744
Dees_Troyc8bafa12013-01-10 15:43:00 +0000745#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
746 if (EcryptFS_Password.size() > 0) {
747 if (unmount_ecryptfs_drive(Mount_Point.c_str()) != 0) {
748 if (Display_Error)
749 LOGE("Unable to unmount ecryptfs for '%s'\n", Mount_Point.c_str());
750 else
751 LOGI("Unable to unmount ecryptfs for '%s'\n", Mount_Point.c_str());
752 } else {
753 LOGI("Successfully unmounted ecryptfs for '%s'\n", Mount_Point.c_str());
754 }
755 }
756#endif
757
Dees_Troy38bd7602012-09-14 13:33:53 -0400758 if (!Symlink_Mount_Point.empty())
759 umount(Symlink_Mount_Point.c_str());
760
Dees_Troy5bf43922012-09-07 16:07:55 -0400761 if (umount(Mount_Point.c_str()) != 0) {
762 if (Display_Error)
763 LOGE("Unable to unmount '%s'\n", Mount_Point.c_str());
764 else
765 LOGI("Unable to unmount '%s'\n", Mount_Point.c_str());
766 return false;
767 } else
768 return true;
769 } else {
770 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400771 }
772}
773
Gary Peck43acadf2012-11-21 21:19:01 -0800774bool TWPartition::Wipe(string New_File_System) {
Dees_Troy16c2b312013-01-15 16:51:18 +0000775 bool wiped = false, update_crypt = false;
776 int check;
777 string Layout_Filename = Mount_Point + "/.layout_version";
778
Dees_Troy38bd7602012-09-14 13:33:53 -0400779 if (!Can_Be_Wiped) {
780 LOGE("Partition '%s' cannot be wiped.\n", Mount_Point.c_str());
781 return false;
782 }
783
Dees_Troyc51f1f92012-09-20 15:32:13 -0400784 if (Mount_Point == "/cache")
785 tmplog_offset = 0;
786
Dees_Troyce675462013-01-09 19:48:21 +0000787#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
788 if (Mount_Point == "/data" && Mount(false)) {
789 if (TWFunc::Path_Exists("/data/system/edk_p_sd"))
790 TWFunc::copy_file("/data/system/edk_p_sd", "/tmp/edk_p_sd", 0600);
791 }
792#endif
793
Dees_Troy16c2b312013-01-15 16:51:18 +0000794 if (Retain_Layout_Version && Mount(false) && TWFunc::Path_Exists(Layout_Filename))
795 TWFunc::copy_file(Layout_Filename, "/.layout_version", 0600);
796 else
797 unlink("/.layout_version");
Dees_Troy38bd7602012-09-14 13:33:53 -0400798
Dees_Troy16c2b312013-01-15 16:51:18 +0000799 if (Has_Data_Media) {
800 wiped = Wipe_Data_Without_Wiping_Media();
801 } else {
Gary Pecke8bc5d72012-12-21 06:45:25 -0800802
Dees_Troy16c2b312013-01-15 16:51:18 +0000803 DataManager::GetValue(TW_RM_RF_VAR, check);
804
805 if (check)
806 wiped = Wipe_RMRF();
807 else if (New_File_System == "ext4")
808 wiped = Wipe_EXT4();
809 else if (New_File_System == "ext2" || New_File_System == "ext3")
810 wiped = Wipe_EXT23(New_File_System);
811 else if (New_File_System == "vfat")
812 wiped = Wipe_FAT();
813 else if (New_File_System == "exfat")
814 wiped = Wipe_EXFAT();
815 else if (New_File_System == "yaffs2")
816 wiped = Wipe_MTD();
817 else {
818 LOGE("Unable to wipe '%s' -- unknown file system '%s'\n", Mount_Point.c_str(), New_File_System.c_str());
819 unlink("/.layout_version");
820 return false;
821 }
822 update_crypt = wiped;
Gary Pecke8bc5d72012-12-21 06:45:25 -0800823 }
Dees_Troy38bd7602012-09-14 13:33:53 -0400824
Gary Pecke8bc5d72012-12-21 06:45:25 -0800825 if (wiped) {
Dees_Troyce675462013-01-09 19:48:21 +0000826#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
827 if (Mount_Point == "/data" && Mount(false)) {
828 if (TWFunc::Path_Exists("/tmp/edk_p_sd")) {
829 Make_Dir("/data/system", true);
830 TWFunc::copy_file("/tmp/edk_p_sd", "/data/system/edk_p_sd", 0600);
831 }
832 }
833#endif
Dees_Troy16c2b312013-01-15 16:51:18 +0000834
Dees_Troy1c1ac442013-01-17 21:42:14 +0000835 if (Mount_Point == "/cache")
836 DataManager::Output_Version();
837
Dees_Troy16c2b312013-01-15 16:51:18 +0000838 if (TWFunc::Path_Exists("/.layout_version") && Mount(false))
839 TWFunc::copy_file("/.layout_version", Layout_Filename, 0600);
840
841 if (update_crypt) {
842 Setup_File_System(false);
843 if (Is_Encrypted && !Is_Decrypted) {
844 // just wiped an encrypted partition back to its unencrypted state
845 Is_Encrypted = false;
846 Is_Decrypted = false;
847 Decrypted_Block_Device = "";
848 if (Mount_Point == "/data") {
849 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
850 DataManager::SetValue(TW_IS_DECRYPTED, 0);
851 }
Gary Pecke8bc5d72012-12-21 06:45:25 -0800852 }
853 }
854 }
855 return wiped;
Dees_Troy51a0e822012-09-05 15:24:24 -0400856}
857
Gary Peck43acadf2012-11-21 21:19:01 -0800858bool TWPartition::Wipe() {
Gary Peck82599a82012-11-21 16:23:12 -0800859 if (Is_File_System(Current_File_System))
860 return Wipe(Current_File_System);
861 else
862 return Wipe(Fstab_File_System);
Gary Peck43acadf2012-11-21 21:19:01 -0800863}
864
Dees_Troye58d5262012-09-21 12:27:57 -0400865bool TWPartition::Wipe_AndSec(void) {
866 if (!Has_Android_Secure)
867 return false;
868
Dees_Troye58d5262012-09-21 12:27:57 -0400869 if (!Mount(true))
870 return false;
871
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500872 ui_print("Wiping .android_secure\n");
873 TWFunc::removeDir(Mount_Point + "/.android_secure/", true);
Dees_Troye58d5262012-09-21 12:27:57 -0400874 return true;
875}
876
Dees_Troy51a0e822012-09-05 15:24:24 -0400877bool TWPartition::Backup(string backup_folder) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400878 if (Backup_Method == FILES)
879 return Backup_Tar(backup_folder);
880 else if (Backup_Method == DD)
881 return Backup_DD(backup_folder);
882 else if (Backup_Method == FLASH_UTILS)
883 return Backup_Dump_Image(backup_folder);
884 LOGE("Unknown backup method for '%s'\n", Mount_Point.c_str());
885 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400886}
887
Dees_Troy43d8b002012-09-17 16:00:01 -0400888bool TWPartition::Check_MD5(string restore_folder) {
889 string Full_Filename;
890 char split_filename[512];
891 int index = 0;
892
893 Full_Filename = restore_folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -0400894 if (!TWFunc::Path_Exists(Full_Filename)) {
895 // This is a split archive, we presume
896 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
897 while (index < 1000 && TWFunc::Path_Exists(split_filename)) {
898 if (TWFunc::Check_MD5(split_filename) == 0) {
899 LOGE("MD5 failed to match on '%s'.\n", split_filename);
900 return false;
901 }
902 index++;
903 sprintf(split_filename, "%s%03i", Full_Filename.c_str(), index);
Dees_Troy43d8b002012-09-17 16:00:01 -0400904 }
Dees_Troy4a2a1262012-09-18 09:33:47 -0400905 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -0400906 } else {
907 // Single file archive
908 if (TWFunc::Check_MD5(Full_Filename) == 0) {
909 LOGE("MD5 failed to match on '%s'.\n", split_filename);
910 return false;
911 } else
912 return true;
913 }
914 return false;
915}
916
Dees_Troy51a0e822012-09-05 15:24:24 -0400917bool TWPartition::Restore(string restore_folder) {
Gary Peck43acadf2012-11-21 21:19:01 -0800918 size_t first_period, second_period;
919 string Restore_File_System;
920
921 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
922 LOGI("Restore filename is: %s\n", Backup_FileName.c_str());
923
924 // Parse backup filename to extract the file system before wiping
925 first_period = Backup_FileName.find(".");
926 if (first_period == string::npos) {
927 LOGE("Unable to find file system (first period).\n");
928 return false;
929 }
930 Restore_File_System = Backup_FileName.substr(first_period + 1, Backup_FileName.size() - first_period - 1);
931 second_period = Restore_File_System.find(".");
932 if (second_period == string::npos) {
933 LOGE("Unable to find file system (second period).\n");
934 return false;
935 }
936 Restore_File_System.resize(second_period);
937 LOGI("Restore file system is: '%s'.\n", Restore_File_System.c_str());
938
939 if (Is_File_System(Restore_File_System))
940 return Restore_Tar(restore_folder, Restore_File_System);
941 else if (Is_Image(Restore_File_System)) {
942 if (Restore_File_System == "emmc")
943 return Restore_DD(restore_folder);
944 else if (Restore_File_System == "mtd" || Restore_File_System == "bml")
945 return Restore_Flash_Image(restore_folder);
946 }
947
Dees_Troy38bd7602012-09-14 13:33:53 -0400948 LOGE("Unknown restore method for '%s'\n", Mount_Point.c_str());
949 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400950}
951
952string TWPartition::Backup_Method_By_Name() {
Dees_Troy38bd7602012-09-14 13:33:53 -0400953 if (Backup_Method == NONE)
954 return "none";
955 else if (Backup_Method == FILES)
956 return "files";
957 else if (Backup_Method == DD)
958 return "dd";
959 else if (Backup_Method == FLASH_UTILS)
960 return "flash_utils";
961 else
962 return "undefined";
963 return "ERROR!";
Dees_Troy51a0e822012-09-05 15:24:24 -0400964}
965
966bool TWPartition::Decrypt(string Password) {
967 LOGI("STUB TWPartition::Decrypt, password: '%s'\n", Password.c_str());
Dees_Troy38bd7602012-09-14 13:33:53 -0400968 // Is this needed?
Dees_Troy51a0e822012-09-05 15:24:24 -0400969 return 1;
970}
971
972bool TWPartition::Wipe_Encryption() {
Dees_Troy38bd7602012-09-14 13:33:53 -0400973 bool Save_Data_Media = Has_Data_Media;
974
975 if (!UnMount(true))
976 return false;
977
Dees_Troy38bd7602012-09-14 13:33:53 -0400978 Has_Data_Media = false;
Gary Pecke8bc5d72012-12-21 06:45:25 -0800979 if (Wipe(Fstab_File_System)) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400980 Has_Data_Media = Save_Data_Media;
981 if (Has_Data_Media && !Symlink_Mount_Point.empty()) {
982 Recreate_Media_Folder();
983 }
Dees_Troyb46a6842012-09-25 11:06:46 -0400984 ui_print("You may need to reboot recovery to be able to use /data again.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400985 return true;
986 } else {
987 Has_Data_Media = Save_Data_Media;
988 LOGE("Unable to format to remove encryption.\n");
989 return false;
990 }
991 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400992}
993
994void TWPartition::Check_FS_Type() {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500995 string blkCommand, result;
996 string blkOutput;
Dees_Troy5bf43922012-09-07 16:07:55 -0400997 char* blk;
998 char* arg;
999 char* ptr;
Dees_Troy4bb33ac2013-01-18 21:05:47 +00001000 int type_found = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -04001001
Dees_Troy68cab492012-12-12 19:29:35 +00001002 if (Fstab_File_System == "yaffs2" || Fstab_File_System == "mtd" || Fstab_File_System == "bml" || Ignore_Blkid)
1003 return; // Running blkid on some mtd devices causes a massive crash or needs to be skipped
Dees_Troy5bf43922012-09-07 16:07:55 -04001004
Dees_Troy38bd7602012-09-14 13:33:53 -04001005 Find_Actual_Block_Device();
Dees_Troy8170a922012-09-18 15:40:25 -04001006 if (!Is_Present)
1007 return;
Dees_Troy51127312012-09-08 13:08:49 -04001008
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001009 blkCommand = "blkid " + Actual_Block_Device;
1010 TWFunc::Exec_Cmd(blkCommand, result);
1011 std::stringstream line(result);
1012 while (getline(line, blkOutput))
Dees_Troy5bf43922012-09-07 16:07:55 -04001013 {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001014 blk = (char*) blkOutput.c_str();
1015 ptr = (char*) blkOutput.c_str();
Dees_Troy63c8df72012-09-10 14:02:05 -04001016 while (*ptr > 32 && *ptr != ':') ptr++;
1017 if (*ptr == 0) continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001018 *ptr = 0;
1019
1020 // Increment by two, but verify that we don't hit a NULL
1021 ptr++;
Dees_Troy63c8df72012-09-10 14:02:05 -04001022 if (*ptr != 0) ptr++;
Dees_Troy5bf43922012-09-07 16:07:55 -04001023
1024 // Now, find the TYPE field
1025 while (1)
1026 {
1027 arg = ptr;
Dees_Troy63c8df72012-09-10 14:02:05 -04001028 while (*ptr > 32) ptr++;
Dees_Troy4bb33ac2013-01-18 21:05:47 +00001029 if (*ptr != 0) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001030 *ptr = 0;
1031 ptr++;
1032 }
1033
Dees_Troy4bb33ac2013-01-18 21:05:47 +00001034 if (strlen(arg) > 6) {
1035 if (memcmp(arg, "TYPE=\"", 6) == 0) {
1036 type_found = 1;
1037 break;
1038 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001039 }
1040
Dees_Troy4bb33ac2013-01-18 21:05:47 +00001041 if (*ptr == 0) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001042 arg = NULL;
1043 break;
1044 }
1045 }
1046
Dees_Troy4bb33ac2013-01-18 21:05:47 +00001047 if (type_found) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001048 arg += 6; // Skip the TYPE=" portion
1049 arg[strlen(arg)-1] = '\0'; // Drop the tail quote
Dees_Troy4bb33ac2013-01-18 21:05:47 +00001050 if (Current_File_System != arg) {
1051 LOGI("'%s' was '%s' now set to '%s'\n", Mount_Point.c_str(), Current_File_System.c_str(), arg);
1052 Current_File_System = arg;
1053 }
1054 } else
Dees_Troy5bf43922012-09-07 16:07:55 -04001055 continue;
Dees_Troy5bf43922012-09-07 16:07:55 -04001056 }
Dees_Troy51a0e822012-09-05 15:24:24 -04001057 return;
1058}
1059
Gary Peck43acadf2012-11-21 21:19:01 -08001060bool TWPartition::Wipe_EXT23(string File_System) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001061 if (!UnMount(true))
1062 return false;
1063
Dees_Troy43d8b002012-09-17 16:00:01 -04001064 if (TWFunc::Path_Exists("/sbin/mke2fs")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001065 string command, result;
Dees_Troy38bd7602012-09-14 13:33:53 -04001066
1067 ui_print("Formatting %s using mke2fs...\n", Display_Name.c_str());
1068 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001069 command = "mke2fs -t " + File_System + " -m 0 " + Actual_Block_Device;
1070 LOGI("mke2fs command: %s\n", command.c_str());
1071 if (TWFunc::Exec_Cmd(command, result) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001072 Current_File_System = File_System;
Dees_Troye58d5262012-09-21 12:27:57 -04001073 Recreate_AndSec_Folder();
Dees_Troy38bd7602012-09-14 13:33:53 -04001074 ui_print("Done.\n");
1075 return true;
1076 } else {
1077 LOGE("Unable to wipe '%s'.\n", Mount_Point.c_str());
1078 return false;
1079 }
1080 } else
1081 return Wipe_RMRF();
1082
1083 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001084}
1085
1086bool TWPartition::Wipe_EXT4() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001087 if (!UnMount(true))
1088 return false;
1089
Dees_Troy43d8b002012-09-17 16:00:01 -04001090 if (TWFunc::Path_Exists("/sbin/make_ext4fs")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001091 string Command, result;
Dees_Troy38bd7602012-09-14 13:33:53 -04001092
1093 ui_print("Formatting %s using make_ext4fs...\n", Display_Name.c_str());
1094 Find_Actual_Block_Device();
1095 Command = "make_ext4fs";
1096 if (!Is_Decrypted && Length != 0) {
1097 // Only use length if we're not decrypted
1098 char len[32];
1099 sprintf(len, "%i", Length);
1100 Command += " -l ";
1101 Command += len;
1102 }
1103 Command += " " + Actual_Block_Device;
1104 LOGI("make_ext4fs command: %s\n", Command.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001105 if (TWFunc::Exec_Cmd(Command, result) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001106 Current_File_System = "ext4";
Dees_Troye58d5262012-09-21 12:27:57 -04001107 Recreate_AndSec_Folder();
Dees_Troy38bd7602012-09-14 13:33:53 -04001108 ui_print("Done.\n");
1109 return true;
1110 } else {
1111 LOGE("Unable to wipe '%s'.\n", Mount_Point.c_str());
1112 return false;
1113 }
1114 } else
Gary Peck43acadf2012-11-21 21:19:01 -08001115 return Wipe_EXT23("ext4");
Dees_Troy38bd7602012-09-14 13:33:53 -04001116
1117 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001118}
1119
1120bool TWPartition::Wipe_FAT() {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001121 string command, result;
Dees_Troy38bd7602012-09-14 13:33:53 -04001122
Dees_Troy43d8b002012-09-17 16:00:01 -04001123 if (TWFunc::Path_Exists("/sbin/mkdosfs")) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001124 if (!UnMount(true))
1125 return false;
1126
1127 ui_print("Formatting %s using mkdosfs...\n", Display_Name.c_str());
1128 Find_Actual_Block_Device();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001129 command = "mkdosfs " + Actual_Block_Device;
1130 if (TWFunc::Exec_Cmd(command, result) == 0) {
Gary Pecke8bc5d72012-12-21 06:45:25 -08001131 Current_File_System = "vfat";
Dees_Troye58d5262012-09-21 12:27:57 -04001132 Recreate_AndSec_Folder();
Dees_Troy38bd7602012-09-14 13:33:53 -04001133 ui_print("Done.\n");
1134 return true;
1135 } else {
1136 LOGE("Unable to wipe '%s'.\n", Mount_Point.c_str());
1137 return false;
1138 }
1139 return true;
1140 }
1141 else
1142 return Wipe_RMRF();
1143
1144 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001145}
1146
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001147bool TWPartition::Wipe_EXFAT() {
1148 string command, result;
1149
1150 if (TWFunc::Path_Exists("/sbin/mkexfatfs")) {
1151 if (!UnMount(true))
1152 return false;
1153
1154 ui_print("Formatting %s using mkexfatfs...\n", Display_Name.c_str());
1155 Find_Actual_Block_Device();
1156 command = "mkexfatfs " + Actual_Block_Device;
1157 if (TWFunc::Exec_Cmd(command, result) == 0) {
1158 Recreate_AndSec_Folder();
1159 ui_print("Done.\n");
1160 return true;
1161 } else {
1162 LOGE("Unable to wipe '%s'.\n", Mount_Point.c_str());
1163 return false;
1164 }
1165 return true;
1166 }
1167 return false;
1168}
1169
Dees_Troy38bd7602012-09-14 13:33:53 -04001170bool TWPartition::Wipe_MTD() {
1171 if (!UnMount(true))
1172 return false;
1173
1174 ui_print("MTD Formatting \"%s\"\n", MTD_Name.c_str());
1175
1176 mtd_scan_partitions();
1177 const MtdPartition* mtd = mtd_find_partition_by_name(MTD_Name.c_str());
1178 if (mtd == NULL) {
1179 LOGE("No mtd partition named '%s'", MTD_Name.c_str());
1180 return false;
1181 }
1182
1183 MtdWriteContext* ctx = mtd_write_partition(mtd);
1184 if (ctx == NULL) {
1185 LOGE("Can't write '%s', failed to format.", MTD_Name.c_str());
1186 return false;
1187 }
1188 if (mtd_erase_blocks(ctx, -1) == -1) {
1189 mtd_write_close(ctx);
1190 LOGE("Failed to format '%s'", MTD_Name.c_str());
1191 return false;
1192 }
1193 if (mtd_write_close(ctx) != 0) {
1194 LOGE("Failed to close '%s'", MTD_Name.c_str());
1195 return false;
1196 }
Gary Pecke8bc5d72012-12-21 06:45:25 -08001197 Current_File_System = "yaffs2";
Dees_Troye58d5262012-09-21 12:27:57 -04001198 Recreate_AndSec_Folder();
Dees_Troy38bd7602012-09-14 13:33:53 -04001199 ui_print("Done.\n");
1200 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001201}
1202
1203bool TWPartition::Wipe_RMRF() {
Dees_Troy38bd7602012-09-14 13:33:53 -04001204 if (!Mount(true))
1205 return false;
1206
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001207 ui_print("Removing all files under '%s'\n", Mount_Point.c_str());
1208 TWFunc::removeDir(Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04001209 Recreate_AndSec_Folder();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001210 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001211}
1212
1213bool TWPartition::Wipe_Data_Without_Wiping_Media() {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001214 string dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04001215
1216 // This handles wiping data on devices with "sdcard" in /data/media
1217 if (!Mount(true))
1218 return false;
1219
1220 ui_print("Wiping data without wiping /data/media ...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001221
1222 DIR* d;
1223 d = opendir("/data");
Dees_Troy16b74352012-11-14 22:27:31 +00001224 if (d != NULL) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001225 struct dirent* de;
1226 while ((de = readdir(d)) != NULL) {
Dees_Troy16b74352012-11-14 22:27:31 +00001227 if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
1228 // The media folder is the "internal sdcard"
1229 // The .layout_version file is responsible for determining whether 4.2 decides up upgrade
1230 // the media folder for multi-user.
1231 if (strcmp(de->d_name, "media") == 0 || strcmp(de->d_name, ".layout_version") == 0) continue;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001232
1233 dir = "/data/";
1234 dir.append(de->d_name);
Dees_Troyce675462013-01-09 19:48:21 +00001235 if (de->d_type == DT_DIR) {
1236 TWFunc::removeDir(dir, false);
bigbiff bigbiff98f1f902013-01-19 18:46:13 -05001237 } 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 +00001238 if (!unlink(dir.c_str()))
1239 LOGI("Unable to unlink '%s'\n", dir.c_str());
1240 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001241 }
1242 closedir(d);
Dees_Troy16b74352012-11-14 22:27:31 +00001243 ui_print("Done.\n");
1244 return true;
Dees_Troy38bd7602012-09-14 13:33:53 -04001245 }
Dees_Troy16b74352012-11-14 22:27:31 +00001246 ui_print("Dirent failed to open /data, error!\n");
1247 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001248}
1249
1250bool TWPartition::Backup_Tar(string backup_folder) {
Dees_Troy4a2a1262012-09-18 09:33:47 -04001251 char back_name[255], split_index[5];
1252 string Full_FileName, Split_FileName, Tar_Args, Command;
1253 int use_compression, index, backup_count;
1254 struct stat st;
Dees_Troy7c2dec82012-09-26 09:49:14 -04001255 unsigned long long total_bsize = 0, file_size;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001256 twrpTar tar;
1257 vector <string> files;
bigbiff bigbiff3bf2b0e2013-01-21 21:26:43 -05001258
Dees_Troy43d8b002012-09-17 16:00:01 -04001259 if (!Mount(true))
1260 return false;
1261
Dees_Troy2c50e182012-09-26 20:05:28 -04001262 if (Backup_Path == "/and-sec") {
1263 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, "Android Secure", "Backing Up");
1264 ui_print("Backing up %s...\n", "Android Secure");
1265 } else {
1266 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
1267 ui_print("Backing up %s...\n", Display_Name.c_str());
1268 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001269
1270 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy43d8b002012-09-17 16:00:01 -04001271
1272 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1273 Backup_FileName = back_name;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001274 Full_FileName = backup_folder + "/" + Backup_FileName;
1275 if (Backup_Size > MAX_ARCHIVE_SIZE) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001276 // This backup needs to be split into multiple archives
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001277 ui_print("Breaking backup file into multiple archives...\n");
Dees_Troye58d5262012-09-21 12:27:57 -04001278 sprintf(back_name, "%s", Backup_Path.c_str());
bigbiff bigbiff3bf2b0e2013-01-21 21:26:43 -05001279 tar.setdir(back_name);
1280 tar.setfn(Full_FileName);
1281 backup_count = tar.splitArchiveThread();
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001282 if (backup_count == -1) {
1283 LOGE("Error tarring split files!\n");
Dees_Troy4a2a1262012-09-18 09:33:47 -04001284 return false;
1285 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001286 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001287 } else {
Dees_Troy4a2a1262012-09-18 09:33:47 -04001288 Full_FileName = backup_folder + "/" + Backup_FileName;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001289 if (use_compression) {
bigbiff bigbiff3bf2b0e2013-01-21 21:26:43 -05001290 tar.setdir(Backup_Path);
1291 tar.setfn(Full_FileName);
1292 if (tar.createTarGZThread() != 0)
1293 return -1;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001294 string gzname = Full_FileName + ".gz";
1295 rename(gzname.c_str(), Full_FileName.c_str());
1296 }
1297 else {
bigbiff bigbiff3bf2b0e2013-01-21 21:26:43 -05001298 tar.setdir(Backup_Path);
1299 tar.setfn(Full_FileName);
1300 if (tar.createTarThread() != 0)
1301 return -1;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001302 }
Dees_Troy7c2dec82012-09-26 09:49:14 -04001303 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
1304 LOGE("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
1305 return false;
1306 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001307 }
1308 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001309}
1310
1311bool TWPartition::Backup_DD(string backup_folder) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001312 char back_name[255];
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001313 string Full_FileName, Command, result;
Dees_Troy43d8b002012-09-17 16:00:01 -04001314 int use_compression;
1315
Dees_Troyb46a6842012-09-25 11:06:46 -04001316 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
Dees_Troy43d8b002012-09-17 16:00:01 -04001317 ui_print("Backing up %s...\n", Display_Name.c_str());
1318
1319 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1320 Backup_FileName = back_name;
1321
1322 Full_FileName = backup_folder + "/" + Backup_FileName;
1323
1324 Command = "dd if=" + Actual_Block_Device + " of='" + Full_FileName + "'";
1325 LOGI("Backup command: '%s'\n", Command.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001326 TWFunc::Exec_Cmd(Command, result);
Dees_Troyc154ac22012-10-12 15:36:47 -04001327 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
1328 LOGE("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
Dees_Troy7c2dec82012-09-26 09:49:14 -04001329 return false;
1330 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001331 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001332}
1333
1334bool TWPartition::Backup_Dump_Image(string backup_folder) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001335 char back_name[255];
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001336 string Full_FileName, Command, result;
Dees_Troy43d8b002012-09-17 16:00:01 -04001337 int use_compression;
1338
Dees_Troyb46a6842012-09-25 11:06:46 -04001339 TWFunc::GUI_Operation_Text(TW_BACKUP_TEXT, Display_Name, "Backing Up");
Dees_Troy43d8b002012-09-17 16:00:01 -04001340 ui_print("Backing up %s...\n", Display_Name.c_str());
1341
1342 sprintf(back_name, "%s.%s.win", Backup_Name.c_str(), Current_File_System.c_str());
1343 Backup_FileName = back_name;
1344
1345 Full_FileName = backup_folder + "/" + Backup_FileName;
1346
1347 Command = "dump_image " + MTD_Name + " '" + Full_FileName + "'";
1348 LOGI("Backup command: '%s'\n", Command.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001349 TWFunc::Exec_Cmd(Command, result);
Dees_Troy7c2dec82012-09-26 09:49:14 -04001350 if (TWFunc::Get_File_Size(Full_FileName) == 0) {
1351 // Actual size may not match backup size due to bad blocks on MTD devices so just check for 0 bytes
1352 LOGE("Backup file size for '%s' is 0 bytes.\n", Full_FileName.c_str());
1353 return false;
1354 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001355 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001356}
1357
Gary Peck43acadf2012-11-21 21:19:01 -08001358bool TWPartition::Restore_Tar(string restore_folder, string Restore_File_System) {
1359 string Full_FileName, Command;
Dees_Troy4a2a1262012-09-18 09:33:47 -04001360 int index = 0;
1361 char split_index[5];
Dees_Troy43d8b002012-09-17 16:00:01 -04001362
Dees_Troye58d5262012-09-21 12:27:57 -04001363 if (Has_Android_Secure) {
1364 ui_print("Wiping android secure...\n");
1365 if (!Wipe_AndSec())
1366 return false;
Gary Peck43acadf2012-11-21 21:19:01 -08001367 } else {
Dees_Troye58d5262012-09-21 12:27:57 -04001368 ui_print("Wiping %s...\n", Display_Name.c_str());
Gary Peck43acadf2012-11-21 21:19:01 -08001369 if (!Wipe(Restore_File_System))
1370 return false;
Dees_Troye58d5262012-09-21 12:27:57 -04001371 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001372
1373 if (!Mount(true))
1374 return false;
1375
Dees_Troyda8b55a2012-12-12 19:18:30 +00001376 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
Dees_Troy43d8b002012-09-17 16:00:01 -04001377 ui_print("Restoring %s...\n", Display_Name.c_str());
Dees_Troy4a2a1262012-09-18 09:33:47 -04001378 Full_FileName = restore_folder + "/" + Backup_FileName;
Dees_Troy43d8b002012-09-17 16:00:01 -04001379 if (!TWFunc::Path_Exists(Full_FileName)) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001380 if (!TWFunc::Path_Exists(Full_FileName)) {
1381 // Backup is multiple archives
1382 LOGI("Backup is multiple archives.\n");
Dees_Troy4a2a1262012-09-18 09:33:47 -04001383 sprintf(split_index, "%03i", index);
1384 Full_FileName = restore_folder + "/" + Backup_FileName + split_index;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001385 while (TWFunc::Path_Exists(Full_FileName)) {
1386 index++;
1387 ui_print("Restoring archive %i...\n", index);
1388 LOGI("Restoring '%s'...\n", Full_FileName.c_str());
1389 twrpTar tar;
bigbiff bigbiff3bf2b0e2013-01-21 21:26:43 -05001390 tar.setdir("/");
1391 tar.setfn(Full_FileName);
1392 if (tar.extractTarThread() != 0)
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001393 return false;
1394 sprintf(split_index, "%03i", index);
1395 Full_FileName = restore_folder + "/" + Backup_FileName + split_index;
1396 }
1397 if (index == 0) {
1398 LOGE("Error locating restore file: '%s'\n", Full_FileName.c_str());
1399 return false;
1400 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001401 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001402 } else {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001403 twrpTar tar;
bigbiff bigbiff3bf2b0e2013-01-21 21:26:43 -05001404 tar.setdir(Backup_Path);
1405 tar.setfn(Full_FileName);
1406 if (tar.extractTarThread() != 0)
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001407 return false;
Dees_Troy43d8b002012-09-17 16:00:01 -04001408 }
1409 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001410}
1411
1412bool TWPartition::Restore_DD(string restore_folder) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001413 string Full_FileName, Command, result;
Dees_Troy43d8b002012-09-17 16:00:01 -04001414
Dees_Troyda8b55a2012-12-12 19:18:30 +00001415 TWFunc::GUI_Operation_Text(TW_RESTORE_TEXT, Display_Name, "Restoring");
Dees_Troy43d8b002012-09-17 16:00:01 -04001416 Full_FileName = restore_folder + "/" + Backup_FileName;
Gary Peck15e623d2012-11-21 21:07:58 -08001417
1418 if (!Find_Partition_Size()) {
1419 LOGE("Unable to find partition size for '%s'\n", Mount_Point.c_str());
1420 return false;
1421 }
1422 unsigned long long backup_size = TWFunc::Get_File_Size(Full_FileName);
1423 if (backup_size > Size) {
1424 LOGE("Size (%iMB) of backup '%s' is larger than target device '%s' (%iMB)\n",
1425 (int)(backup_size / 1048576LLU), Full_FileName.c_str(),
1426 Actual_Block_Device.c_str(), (int)(Size / 1048576LLU));
1427 return false;
1428 }
1429
1430 ui_print("Restoring %s...\n", Display_Name.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -04001431 Command = "dd bs=4096 if='" + Full_FileName + "' of=" + Actual_Block_Device;
1432 LOGI("Restore command: '%s'\n", Command.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001433 TWFunc::Exec_Cmd(Command, result);
Dees_Troy43d8b002012-09-17 16:00:01 -04001434 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001435}
1436
1437bool TWPartition::Restore_Flash_Image(string restore_folder) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001438 string Full_FileName, Command, result;
Dees_Troy43d8b002012-09-17 16:00:01 -04001439
1440 ui_print("Restoring %s...\n", Display_Name.c_str());
1441 Full_FileName = restore_folder + "/" + Backup_FileName;
1442 // Sometimes flash image doesn't like to flash due to the first 2KB matching, so we erase first to ensure that it flashes
1443 Command = "erase_image " + MTD_Name;
1444 LOGI("Erase command: '%s'\n", Command.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001445 TWFunc::Exec_Cmd(Command, result);
Dees_Troy43d8b002012-09-17 16:00:01 -04001446 Command = "flash_image " + MTD_Name + " '" + Full_FileName + "'";
1447 LOGI("Restore command: '%s'\n", Command.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001448 TWFunc::Exec_Cmd(Command, result);
Dees_Troy43d8b002012-09-17 16:00:01 -04001449 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001450}
Dees_Troy5bf43922012-09-07 16:07:55 -04001451
1452bool TWPartition::Update_Size(bool Display_Error) {
Dees_Troy0550cfb2012-10-13 11:56:13 -04001453 bool ret = false, Was_Already_Mounted = false;
Dees_Troy51127312012-09-08 13:08:49 -04001454
Dees_Troyab10ee22012-09-21 14:27:30 -04001455 if (!Can_Be_Mounted && !Is_Encrypted)
Dees_Troy5bf43922012-09-07 16:07:55 -04001456 return false;
1457
Dees_Troy0550cfb2012-10-13 11:56:13 -04001458 Was_Already_Mounted = Is_Mounted();
Dees_Troy38bd7602012-09-14 13:33:53 -04001459 if (Removable || Is_Encrypted) {
1460 if (!Mount(false))
1461 return true;
1462 } else if (!Mount(Display_Error))
Dees_Troy5bf43922012-09-07 16:07:55 -04001463 return false;
Dees_Troy51127312012-09-08 13:08:49 -04001464
1465 ret = Get_Size_Via_statfs(Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001466 if (!ret || Size == 0) {
1467 if (!Get_Size_Via_df(Display_Error)) {
1468 if (!Was_Already_Mounted)
1469 UnMount(false);
Dees_Troy51127312012-09-08 13:08:49 -04001470 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001471 }
1472 }
Dees_Troy51127312012-09-08 13:08:49 -04001473
Dees_Troy5bf43922012-09-07 16:07:55 -04001474 if (Has_Data_Media) {
1475 if (Mount(Display_Error)) {
Dees_Troy51127312012-09-08 13:08:49 -04001476 unsigned long long data_media_used, actual_data;
Dees_Troy43d8b002012-09-17 16:00:01 -04001477 Used = TWFunc::Get_Folder_Size("/data", Display_Error);
1478 data_media_used = TWFunc::Get_Folder_Size("/data/media", Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -04001479 actual_data = Used - data_media_used;
Dees_Troy5bf43922012-09-07 16:07:55 -04001480 Backup_Size = actual_data;
Dees_Troy51127312012-09-08 13:08:49 -04001481 int bak = (int)(Backup_Size / 1048576LLU);
1482 int total = (int)(Size / 1048576LLU);
1483 int us = (int)(Used / 1048576LLU);
1484 int fre = (int)(Free / 1048576LLU);
1485 int datmed = (int)(data_media_used / 1048576LLU);
1486 LOGI("Data backup size is %iMB, size: %iMB, used: %iMB, free: %iMB, in data/media: %iMB.\n", bak, total, us, fre, datmed);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001487 } else {
1488 if (!Was_Already_Mounted)
1489 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04001490 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001491 }
Dees_Troye58d5262012-09-21 12:27:57 -04001492 } else if (Has_Android_Secure) {
1493 if (Mount(Display_Error))
1494 Backup_Size = TWFunc::Get_Folder_Size(Backup_Path, Display_Error);
Dees_Troy0550cfb2012-10-13 11:56:13 -04001495 else {
1496 if (!Was_Already_Mounted)
1497 UnMount(false);
Dees_Troye58d5262012-09-21 12:27:57 -04001498 return false;
Dees_Troy0550cfb2012-10-13 11:56:13 -04001499 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001500 }
Dees_Troy0550cfb2012-10-13 11:56:13 -04001501 if (!Was_Already_Mounted)
1502 UnMount(false);
Dees_Troy5bf43922012-09-07 16:07:55 -04001503 return true;
Dees_Troy51127312012-09-08 13:08:49 -04001504}
Dees_Troy38bd7602012-09-14 13:33:53 -04001505
1506void TWPartition::Find_Actual_Block_Device(void) {
1507 if (Is_Decrypted) {
1508 Actual_Block_Device = Decrypted_Block_Device;
Dees_Troy43d8b002012-09-17 16:00:01 -04001509 if (TWFunc::Path_Exists(Primary_Block_Device))
Dees_Troy38bd7602012-09-14 13:33:53 -04001510 Is_Present = true;
Dees_Troy43d8b002012-09-17 16:00:01 -04001511 } else if (TWFunc::Path_Exists(Primary_Block_Device)) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001512 Is_Present = true;
1513 Actual_Block_Device = Primary_Block_Device;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001514 return;
1515 }
1516 if (Is_Decrypted) {
Dees_Troy43d8b002012-09-17 16:00:01 -04001517 } else if (!Alternate_Block_Device.empty() && TWFunc::Path_Exists(Alternate_Block_Device)) {
Dees_Troy3f04d032012-10-07 18:20:09 -04001518 Actual_Block_Device = Alternate_Block_Device;
Dees_Troy38bd7602012-09-14 13:33:53 -04001519 Is_Present = true;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001520 } else {
Dees_Troy38bd7602012-09-14 13:33:53 -04001521 Is_Present = false;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001522 }
Dees_Troy38bd7602012-09-14 13:33:53 -04001523}
1524
1525void TWPartition::Recreate_Media_Folder(void) {
1526 string Command;
1527
1528 if (!Mount(true)) {
1529 LOGE("Unable to recreate /data/media folder.\n");
Dees_Troyb46a6842012-09-25 11:06:46 -04001530 } else if (!TWFunc::Path_Exists("/data/media")) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001531 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04001532 LOGI("Recreating /data/media folder.\n");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001533 mkdir("/data/media", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
1534 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troy38bd7602012-09-14 13:33:53 -04001535 }
Dees_Troy43d8b002012-09-17 16:00:01 -04001536}
Dees_Troye58d5262012-09-21 12:27:57 -04001537
1538void TWPartition::Recreate_AndSec_Folder(void) {
Dees_Troye58d5262012-09-21 12:27:57 -04001539 if (!Has_Android_Secure)
1540 return;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001541 LOGI("Creating .android_secure: %s\n", Symlink_Path.c_str());
Dees_Troye58d5262012-09-21 12:27:57 -04001542 if (!Mount(true)) {
1543 LOGE("Unable to recreate android secure folder.\n");
1544 } else if (!TWFunc::Path_Exists(Symlink_Path)) {
1545 LOGI("Recreating android secure folder.\n");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001546 PartitionManager.Mount_By_Path(Symlink_Mount_Point, true);
1547 mkdir(Symlink_Path.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
1548 PartitionManager.UnMount_By_Path(Symlink_Mount_Point, true);
Dees_Troye58d5262012-09-21 12:27:57 -04001549 }
1550}