blob: b8a95ff265f91de392fac3b488636032a3aad0cf [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002 Copyright 2014 to 2017 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>
24#include <unistd.h>
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060025#include <map>
Dees_Troy5bf43922012-09-07 16:07:55 -040026#include <vector>
Dees_Troy63c8df72012-09-10 14:02:05 -040027#include <dirent.h>
28#include <time.h>
Dees_Troy8170a922012-09-18 15:40:25 -040029#include <errno.h>
30#include <fcntl.h>
bigbiffce8f83c2015-12-12 18:30:21 -050031#include <zlib.h>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050032#include <iostream>
33#include <iomanip>
Ethan Yonker8613dc02014-09-11 09:28:20 -050034#include <sys/wait.h>
Ethan Yonker483e9f42016-01-11 22:21:18 -060035#include <linux/fs.h>
36#include <sys/mount.h>
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060037
38#include <sys/poll.h>
39#include <sys/socket.h>
40#include <linux/types.h>
41#include <linux/netlink.h>
42
Dees_Troy51a0e822012-09-05 15:24:24 -040043#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000044#include "twcommon.h"
Dees_Troy51a0e822012-09-05 15:24:24 -040045#include "partitions.hpp"
Dees_Troy5bf43922012-09-07 16:07:55 -040046#include "data.hpp"
Dees_Troy38bd7602012-09-14 13:33:53 -040047#include "twrp-functions.hpp"
Ethan Yonkerb5fab762016-01-28 14:03:33 -060048#include "fixContexts.hpp"
Ethan Yonker3fdcda42016-11-30 12:29:37 -060049#include "exclude.hpp"
Ethan Yonker4b94cfd2014-12-11 10:00:45 -060050#include "set_metadata.h"
bigbiff7abc5fe2015-01-17 16:53:12 -050051#include "tw_atomic.hpp"
Ethan Yonker74db1572015-10-28 12:44:49 -050052#include "gui/gui.hpp"
Ethan Yonker472f5062016-02-25 13:47:30 -060053#include "progresstracking.hpp"
bigbiff bigbiff56cf5642016-08-19 17:43:45 -040054#include "twrpDigestDriver.hpp"
bigbiffce8f83c2015-12-12 18:30:21 -050055#include "adbbu/libtwadbbu.hpp"
Dees_Troy38bd7602012-09-14 13:33:53 -040056
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -040057#ifdef TW_HAS_MTP
58#include "mtp/mtp_MtpServer.hpp"
59#include "mtp/twrpMtp.hpp"
Ethan Yonker726a0202014-12-16 20:01:38 -060060#include "mtp/MtpMessage.hpp"
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -040061#endif
62
Dees Troy6f6441d2014-01-23 02:07:03 +000063extern "C" {
64 #include "cutils/properties.h"
Ethan Yonker74db1572015-10-28 12:44:49 -050065 #include "gui/gui.h"
Dees Troy6f6441d2014-01-23 02:07:03 +000066}
67
Dees_Troy5bf43922012-09-07 16:07:55 -040068#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker253368a2014-11-25 15:00:52 -060069 #include "crypto/lollipop/cryptfs.h"
Ethan Yonker66a19492015-12-10 10:19:45 -060070 #include "gui/rapidxml.hpp"
71 #include "gui/pages.hpp"
Ethan Yonkerbd7492d2016-12-07 13:55:01 -060072 #ifdef TW_INCLUDE_FBE
73 #include "crypto/ext4crypt/Decrypt.h"
Ethan Yonker93382822018-11-01 15:25:31 -050074 #ifdef TW_INCLUDE_FBE_METADATA_DECRYPT
75 #include "crypto/ext4crypt/MetadataCrypt.h"
76 #endif
Ethan Yonkerbd7492d2016-12-07 13:55:01 -060077 #endif
nkk7171c6c502017-01-05 23:55:05 +020078 #ifdef TW_CRYPTO_USE_SYSTEM_VOLD
79 #include "crypto/vold_decrypt/vold_decrypt.h"
80 #endif
Dees_Troy5bf43922012-09-07 16:07:55 -040081#endif
Dees_Troy51a0e822012-09-05 15:24:24 -040082
Ethan Yonker1b190162016-12-05 15:25:19 -060083#ifdef AB_OTA_UPDATER
84#include <hardware/hardware.h>
85#include <hardware/boot_control.h>
86#endif
87
Ethan Yonker6277c792014-09-15 14:54:30 -050088extern bool datamedia;
89
bigbiff bigbiff34684ff2013-12-01 21:03:45 -050090TWPartitionManager::TWPartitionManager(void) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -040091 mtp_was_enabled = false;
Ethan Yonker726a0202014-12-16 20:01:38 -060092 mtp_write_fd = -1;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060093 uevent_pfd.fd = -1;
bigbiff7abc5fe2015-01-17 16:53:12 -050094 stop_backup.set_value(0);
Ethan Yonker1b190162016-12-05 15:25:19 -060095#ifdef AB_OTA_UPDATER
96 char slot_suffix[PROPERTY_VALUE_MAX];
Ethan Yonkerfefe5912017-09-30 22:22:13 -050097 property_get("ro.boot.slot_suffix", slot_suffix, "error");
98 if (strcmp(slot_suffix, "error") == 0)
99 property_get("ro.boot.slot", slot_suffix, "error");
Ethan Yonker1b190162016-12-05 15:25:19 -0600100 Active_Slot_Display = "";
Ethan Yonkerfefe5912017-09-30 22:22:13 -0500101 if (strcmp(slot_suffix, "_a") == 0 || strcmp(slot_suffix, "a") == 0)
Ethan Yonker1b190162016-12-05 15:25:19 -0600102 Set_Active_Slot("A");
103 else
104 Set_Active_Slot("B");
105#endif
bigbiff bigbiff34684ff2013-12-01 21:03:45 -0500106}
107
Dees_Troy51a0e822012-09-05 15:24:24 -0400108int TWPartitionManager::Process_Fstab(string Fstab_Filename, bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400109 FILE *fstabFile;
110 char fstab_line[MAX_FSTAB_LINE_LENGTH];
Dees Troy02a64532014-03-19 15:23:32 +0000111 TWPartition* settings_partition = NULL;
Matt Mowerbf4efa32014-04-14 23:25:26 -0500112 TWPartition* andsec_partition = NULL;
Ethan Yonker726a0202014-12-16 20:01:38 -0600113 unsigned int storageid = 1 << 16; // upper 16 bits are for physical storage device, we pretend to have only one
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600114 std::map<string, Flags_Map> twrp_flags;
115
116 fstabFile = fopen("/etc/twrp.flags", "rt");
117 if (fstabFile != NULL) {
118 LOGINFO("reading /etc/twrp.flags\n");
119 while (fgets(fstab_line, sizeof(fstab_line), fstabFile) != NULL) {
120 if (fstab_line[0] != '/')
121 continue;
122
123 size_t line_size = strlen(fstab_line);
124 if (fstab_line[line_size - 1] != '\n')
125 fstab_line[line_size] = '\n';
126 Flags_Map line_flags;
127 line_flags.Primary_Block_Device = "";
128 line_flags.Alternate_Block_Device = "";
129 line_flags.fstab_line = (char*)malloc(MAX_FSTAB_LINE_LENGTH);
130 if (!line_flags.fstab_line) {
131 LOGERR("malloc error on line_flags.fstab_line\n");
132 return false;
133 }
134 memcpy(line_flags.fstab_line, fstab_line, MAX_FSTAB_LINE_LENGTH);
135 bool found_separator = false;
136 char *fs_loc = NULL;
137 char *block_loc = NULL;
138 char *flags_loc = NULL;
139 size_t index, item_index = 0;
140 for (index = 0; index < line_size; index++) {
141 if (fstab_line[index] <= 32) {
142 fstab_line[index] = '\0';
143 found_separator = true;
144 } else if (found_separator) {
145 if (item_index == 0) {
146 fs_loc = fstab_line + index;
147 } else if (item_index == 1) {
148 block_loc = fstab_line + index;
149 } else if (item_index > 1) {
150 char *ptr = fstab_line + index;
151 if (*ptr == '/') {
152 line_flags.Alternate_Block_Device = ptr;
153 } else if (strlen(ptr) > strlen("flags=") && strncmp(ptr, "flags=", strlen("flags=")) == 0) {
154 flags_loc = ptr;
155 // Once we find the flags=, we're done scanning the line
156 break;
157 }
158 }
159 found_separator = false;
160 item_index++;
161 }
162 }
163 if (block_loc)
164 line_flags.Primary_Block_Device = block_loc;
165 if (fs_loc)
166 line_flags.File_System = fs_loc;
167 if (flags_loc)
168 line_flags.Flags = flags_loc;
169 string Mount_Point = fstab_line;
170 twrp_flags[Mount_Point] = line_flags;
171 memset(fstab_line, 0, sizeof(fstab_line));
172 }
173 fclose(fstabFile);
174 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400175
176 fstabFile = fopen(Fstab_Filename.c_str(), "rt");
177 if (fstabFile == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000178 LOGERR("Critical Error: Unable to open fstab at '%s'.\n", Fstab_Filename.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400179 return false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600180 } else
181 LOGINFO("Reading %s\n", Fstab_Filename.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400182
183 while (fgets(fstab_line, sizeof(fstab_line), fstabFile) != NULL) {
184 if (fstab_line[0] != '/')
185 continue;
186
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600187 if (strstr(fstab_line, "swap"))
188 continue; // Skip swap in recovery
189
190 size_t line_size = strlen(fstab_line);
191 if (fstab_line[line_size - 1] != '\n')
192 fstab_line[line_size] = '\n';
Dees_Troy2a923582012-09-20 12:13:34 -0400193
Matt Mower2b2dd152016-04-26 11:24:08 -0500194 TWPartition* partition = new TWPartition();
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600195 if (partition->Process_Fstab_Line(fstab_line, Display_Error, &twrp_flags))
Ethan Yonkerc05c5982014-03-13 09:19:56 -0500196 Partitions.push_back(partition);
Matt Mower72c87ce2016-04-26 14:34:56 -0500197 else
Dees_Troy5bf43922012-09-07 16:07:55 -0400198 delete partition;
Matt Mower2b2dd152016-04-26 11:24:08 -0500199
200 memset(fstab_line, 0, sizeof(fstab_line));
Dees_Troy5bf43922012-09-07 16:07:55 -0400201 }
202 fclose(fstabFile);
Matt Mower72c87ce2016-04-26 14:34:56 -0500203
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600204 if (twrp_flags.size() > 0) {
205 LOGINFO("Processing remaining twrp.flags\n");
206 // Add any items from twrp.flags that did not exist in the recovery.fstab
207 for (std::map<string, Flags_Map>::iterator mapit=twrp_flags.begin(); mapit!=twrp_flags.end(); mapit++) {
208 if (Find_Partition_By_Path(mapit->first) == NULL) {
209 TWPartition* partition = new TWPartition();
210 if (partition->Process_Fstab_Line(mapit->second.fstab_line, Display_Error, NULL))
211 Partitions.push_back(partition);
212 else
213 delete partition;
214 }
215 if (mapit->second.fstab_line)
216 free(mapit->second.fstab_line);
217 mapit->second.fstab_line = NULL;
218 }
219 }
220 LOGINFO("Done processing fstab files\n");
221
Matt Mower72c87ce2016-04-26 14:34:56 -0500222 std::vector<TWPartition*>::iterator iter;
223 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
224 (*iter)->Partition_Post_Processing(Display_Error);
225
226 if ((*iter)->Is_Storage) {
227 ++storageid;
228 (*iter)->MTP_Storage_ID = storageid;
229 }
230
231 if (!settings_partition && (*iter)->Is_Settings_Storage && (*iter)->Is_Present)
232 settings_partition = (*iter);
233 else
234 (*iter)->Is_Settings_Storage = false;
235
236 if (!andsec_partition && (*iter)->Has_Android_Secure && (*iter)->Is_Present)
237 andsec_partition = (*iter);
238 else
239 (*iter)->Has_Android_Secure = false;
240 }
241
Ethan Yonker6277c792014-09-15 14:54:30 -0500242 if (!datamedia && !settings_partition && Find_Partition_By_Path("/sdcard") == NULL && Find_Partition_By_Path("/internal_sd") == NULL && Find_Partition_By_Path("/internal_sdcard") == NULL && Find_Partition_By_Path("/emmc") == NULL) {
243 // Attempt to automatically identify /data/media emulated storage devices
244 TWPartition* Dat = Find_Partition_By_Path("/data");
245 if (Dat) {
246 LOGINFO("Using automatic handling for /data/media emulated storage device.\n");
247 datamedia = true;
that9e0593e2014-10-08 00:01:24 +0200248 Dat->Setup_Data_Media();
Ethan Yonker6277c792014-09-15 14:54:30 -0500249 settings_partition = Dat;
Ethan Yonker726a0202014-12-16 20:01:38 -0600250 // Since /data was not considered a storage partition earlier, we still need to assign an MTP ID
251 ++storageid;
252 Dat->MTP_Storage_ID = storageid;
Ethan Yonker6277c792014-09-15 14:54:30 -0500253 }
254 }
Dees Troy02a64532014-03-19 15:23:32 +0000255 if (!settings_partition) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500256 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
257 if ((*iter)->Is_Storage) {
Dees Troy02a64532014-03-19 15:23:32 +0000258 settings_partition = (*iter);
Dees_Troya13d74f2013-03-24 08:54:55 -0500259 break;
260 }
261 }
Dees Troy02a64532014-03-19 15:23:32 +0000262 if (!settings_partition)
Dees_Troy2673cec2013-04-02 20:22:16 +0000263 LOGERR("Unable to locate storage partition for storing settings file.\n");
Dees_Troya13d74f2013-03-24 08:54:55 -0500264 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400265 if (!Write_Fstab()) {
266 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000267 LOGERR("Error creating fstab\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400268 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000269 LOGINFO("Error creating fstab\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400270 }
Matt Mowered71fa32014-04-16 13:21:47 -0500271
Matt Mowerbf4efa32014-04-14 23:25:26 -0500272 if (andsec_partition) {
273 Setup_Android_Secure_Location(andsec_partition);
Matt Mowered71fa32014-04-16 13:21:47 -0500274 } else if (settings_partition) {
Matt Mowerbf4efa32014-04-14 23:25:26 -0500275 Setup_Android_Secure_Location(settings_partition);
276 }
Matt Mowered71fa32014-04-16 13:21:47 -0500277 if (settings_partition) {
278 Setup_Settings_Storage_Partition(settings_partition);
279 }
Ethan Yonker253368a2014-11-25 15:00:52 -0600280#ifdef TW_INCLUDE_CRYPTO
Ethan Yonkercceebb82014-11-18 10:17:59 -0600281 TWPartition* Decrypt_Data = Find_Partition_By_Path("/data");
282 if (Decrypt_Data && Decrypt_Data->Is_Encrypted && !Decrypt_Data->Is_Decrypted) {
Ethan Yonker93382822018-11-01 15:25:31 -0500283 if (!Decrypt_Data->Key_Directory.empty() && Mount_By_Path(Decrypt_Data->Key_Directory, false)) {
284#ifdef TW_INCLUDE_FBE_METADATA_DECRYPT
285 if (e4crypt_mount_metadata_encrypted(Decrypt_Data->Mount_Point, false, Decrypt_Data->Key_Directory, Decrypt_Data->Actual_Block_Device, &Decrypt_Data->Decrypted_Block_Device)) {
286 LOGINFO("Successfully decrypted metadata encrypted data partition with new block device: '%s'\n", Decrypt_Data->Decrypted_Block_Device.c_str());
287 property_set("ro.crypto.state", "encrypted");
288 Decrypt_Data->Is_Decrypted = true; // Needed to make the mount function work correctly
289 int retry_count = 10;
290 while (!Decrypt_Data->Mount(false) && --retry_count)
291 usleep(500);
292 if (Decrypt_Data->Mount(false)) {
293 Decrypt_Data->Decrypt_FBE_DE();
294 } else {
295 LOGINFO("Failed to mount data after metadata decrypt\n");
296 }
297 } else {
298 LOGINFO("Unable to decrypt metadata encryption\n");
299 }
300#else
301 LOGERR("Metadata FBE decrypt support not present in this TWRP\n");
302#endif
303 }
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600304 if (Decrypt_Data->Is_FBE) {
305 if (DataManager::GetIntValue(TW_CRYPTO_PWTYPE) == 0) {
306 if (Decrypt_Device("!") == 0) {
307 gui_msg("decrypt_success=Successfully decrypted with default password.");
308 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
309 } else {
310 gui_err("unable_to_decrypt=Unable to decrypt with default password.");
311 }
Ethan Yonkercceebb82014-11-18 10:17:59 -0600312 }
313 } else {
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600314 int password_type = cryptfs_get_password_type();
315 if (password_type == CRYPT_TYPE_DEFAULT) {
316 LOGINFO("Device is encrypted with the default password, attempting to decrypt.\n");
317 if (Decrypt_Device("default_password") == 0) {
318 gui_msg("decrypt_success=Successfully decrypted with default password.");
319 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
320 } else {
321 gui_err("unable_to_decrypt=Unable to decrypt with default password.");
322 }
323 } else {
324 DataManager::SetValue("TW_CRYPTO_TYPE", password_type);
325 }
Ethan Yonkercceebb82014-11-18 10:17:59 -0600326 }
327 }
Ethan Yonker66a19492015-12-10 10:19:45 -0600328 if (Decrypt_Data && (!Decrypt_Data->Is_Encrypted || Decrypt_Data->Is_Decrypted) && Decrypt_Data->Mount(false)) {
329 Decrypt_Adopted();
330 }
Ethan Yonkercceebb82014-11-18 10:17:59 -0600331#endif
Dees_Troy51127312012-09-08 13:08:49 -0400332 Update_System_Details();
Dees_Troyd0384ef2012-10-12 12:15:42 -0400333 UnMount_Main_Partitions();
Ethan Yonker1b190162016-12-05 15:25:19 -0600334#ifdef AB_OTA_UPDATER
335 DataManager::SetValue("tw_active_slot", Get_Active_Slot_Display());
336#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600337 setup_uevent();
Dees_Troy5bf43922012-09-07 16:07:55 -0400338 return true;
339}
340
341int TWPartitionManager::Write_Fstab(void) {
342 FILE *fp;
343 std::vector<TWPartition*>::iterator iter;
344 string Line;
345
346 fp = fopen("/etc/fstab", "w");
347 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000348 LOGINFO("Can not open /etc/fstab.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400349 return false;
350 }
Dees_Troy63c8df72012-09-10 14:02:05 -0400351 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy51127312012-09-08 13:08:49 -0400352 if ((*iter)->Can_Be_Mounted) {
dianlujitao7d304c72016-01-02 12:15:50 +0800353 Line = (*iter)->Actual_Block_Device + " " + (*iter)->Mount_Point + " " + (*iter)->Current_File_System + " rw 0 0\n";
Dees_Troy5bf43922012-09-07 16:07:55 -0400354 fputs(Line.c_str(), fp);
Dees_Troy91862e62013-04-04 23:48:21 +0000355 }
356 // Handle subpartition tracking
357 if ((*iter)->Is_SubPartition) {
358 TWPartition* ParentPartition = Find_Partition_By_Path((*iter)->SubPartition_Of);
359 if (ParentPartition)
360 ParentPartition->Has_SubPartition = true;
361 else
362 LOGERR("Unable to locate parent partition '%s' of '%s'\n", (*iter)->SubPartition_Of.c_str(), (*iter)->Mount_Point.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400363 }
364 }
365 fclose(fp);
366 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400367}
368
Ethan Yonkerc05c5982014-03-13 09:19:56 -0500369void TWPartitionManager::Setup_Settings_Storage_Partition(TWPartition* Part) {
Ethan Yonkerc05c5982014-03-13 09:19:56 -0500370 DataManager::SetValue("tw_settings_path", Part->Storage_Path);
371 DataManager::SetValue("tw_storage_path", Part->Storage_Path);
372 LOGINFO("Settings storage is '%s'\n", Part->Storage_Path.c_str());
373}
374
Matt Mowerbf4efa32014-04-14 23:25:26 -0500375void TWPartitionManager::Setup_Android_Secure_Location(TWPartition* Part) {
376 if (Part->Has_Android_Secure)
377 Part->Setup_AndSec();
Ethan Yonker6277c792014-09-15 14:54:30 -0500378 else if (!datamedia)
Matt Mowerbf4efa32014-04-14 23:25:26 -0500379 Part->Setup_AndSec();
Matt Mowerbf4efa32014-04-14 23:25:26 -0500380}
381
Dees_Troy8170a922012-09-18 15:40:25 -0400382void TWPartitionManager::Output_Partition_Logging(void) {
383 std::vector<TWPartition*>::iterator iter;
384
385 printf("\n\nPartition Logs:\n");
386 for (iter = Partitions.begin(); iter != Partitions.end(); iter++)
387 Output_Partition((*iter));
388}
389
390void TWPartitionManager::Output_Partition(TWPartition* Part) {
391 unsigned long long mb = 1048576;
392
Gary Peck004d48b2012-11-21 16:28:18 -0800393 printf("%s | %s | Size: %iMB", Part->Mount_Point.c_str(), Part->Actual_Block_Device.c_str(), (int)(Part->Size / mb));
Dees_Troy8170a922012-09-18 15:40:25 -0400394 if (Part->Can_Be_Mounted) {
Gary Peck004d48b2012-11-21 16:28:18 -0800395 printf(" Used: %iMB Free: %iMB Backup Size: %iMB", (int)(Part->Used / mb), (int)(Part->Free / mb), (int)(Part->Backup_Size / mb));
Dees_Troy8170a922012-09-18 15:40:25 -0400396 }
Gary Peck004d48b2012-11-21 16:28:18 -0800397 printf("\n Flags: ");
Dees_Troya13d74f2013-03-24 08:54:55 -0500398 if (Part->Can_Be_Mounted)
399 printf("Can_Be_Mounted ");
Gary Peck004d48b2012-11-21 16:28:18 -0800400 if (Part->Can_Be_Wiped)
401 printf("Can_Be_Wiped ");
Hashcodedabfd492013-08-29 22:45:30 -0700402 if (Part->Use_Rm_Rf)
403 printf("Use_Rm_Rf ");
Dees_Troya13d74f2013-03-24 08:54:55 -0500404 if (Part->Can_Be_Backed_Up)
405 printf("Can_Be_Backed_Up ");
Gary Peck004d48b2012-11-21 16:28:18 -0800406 if (Part->Wipe_During_Factory_Reset)
407 printf("Wipe_During_Factory_Reset ");
408 if (Part->Wipe_Available_in_GUI)
409 printf("Wipe_Available_in_GUI ");
410 if (Part->Is_SubPartition)
411 printf("Is_SubPartition ");
412 if (Part->Has_SubPartition)
413 printf("Has_SubPartition ");
414 if (Part->Removable)
415 printf("Removable ");
416 if (Part->Is_Present)
417 printf("IsPresent ");
418 if (Part->Can_Be_Encrypted)
419 printf("Can_Be_Encrypted ");
420 if (Part->Is_Encrypted)
421 printf("Is_Encrypted ");
422 if (Part->Is_Decrypted)
423 printf("Is_Decrypted ");
424 if (Part->Has_Data_Media)
425 printf("Has_Data_Media ");
Dees_Troy83bd4832013-05-04 12:39:56 +0000426 if (Part->Can_Encrypt_Backup)
427 printf("Can_Encrypt_Backup ");
428 if (Part->Use_Userdata_Encryption)
429 printf("Use_Userdata_Encryption ");
Gary Peck004d48b2012-11-21 16:28:18 -0800430 if (Part->Has_Android_Secure)
431 printf("Has_Android_Secure ");
432 if (Part->Is_Storage)
433 printf("Is_Storage ");
Dees_Troya13d74f2013-03-24 08:54:55 -0500434 if (Part->Is_Settings_Storage)
435 printf("Is_Settings_Storage ");
Dees_Troy68cab492012-12-12 19:29:35 +0000436 if (Part->Ignore_Blkid)
437 printf("Ignore_Blkid ");
Dees_Troy16c2b312013-01-15 16:51:18 +0000438 if (Part->Retain_Layout_Version)
439 printf("Retain_Layout_Version ");
Ethan Yonker253368a2014-11-25 15:00:52 -0600440 if (Part->Mount_To_Decrypt)
441 printf("Mount_To_Decrypt ");
Ethan Yonker96af84a2015-01-05 14:58:36 -0600442 if (Part->Can_Flash_Img)
443 printf("Can_Flash_Img ");
Ethan Yonker66a19492015-12-10 10:19:45 -0600444 if (Part->Is_Adopted_Storage)
445 printf("Is_Adopted_Storage ");
Ethan Yonker1b190162016-12-05 15:25:19 -0600446 if (Part->SlotSelect)
447 printf("SlotSelect ");
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600448 if (Part->Mount_Read_Only)
449 printf("Mount_Read_Only ");
Gary Peck004d48b2012-11-21 16:28:18 -0800450 printf("\n");
451 if (!Part->SubPartition_Of.empty())
452 printf(" SubPartition_Of: %s\n", Part->SubPartition_Of.c_str());
453 if (!Part->Symlink_Path.empty())
454 printf(" Symlink_Path: %s\n", Part->Symlink_Path.c_str());
455 if (!Part->Symlink_Mount_Point.empty())
456 printf(" Symlink_Mount_Point: %s\n", Part->Symlink_Mount_Point.c_str());
457 if (!Part->Primary_Block_Device.empty())
458 printf(" Primary_Block_Device: %s\n", Part->Primary_Block_Device.c_str());
459 if (!Part->Alternate_Block_Device.empty())
460 printf(" Alternate_Block_Device: %s\n", Part->Alternate_Block_Device.c_str());
461 if (!Part->Decrypted_Block_Device.empty())
462 printf(" Decrypted_Block_Device: %s\n", Part->Decrypted_Block_Device.c_str());
Ethan Yonker253368a2014-11-25 15:00:52 -0600463 if (!Part->Crypto_Key_Location.empty() && Part->Crypto_Key_Location != "footer")
464 printf(" Crypto_Key_Location: %s\n", Part->Crypto_Key_Location.c_str());
Gary Peck004d48b2012-11-21 16:28:18 -0800465 if (Part->Length != 0)
466 printf(" Length: %i\n", Part->Length);
467 if (!Part->Display_Name.empty())
468 printf(" Display_Name: %s\n", Part->Display_Name.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500469 if (!Part->Storage_Name.empty())
470 printf(" Storage_Name: %s\n", Part->Storage_Name.c_str());
Gary Peck004d48b2012-11-21 16:28:18 -0800471 if (!Part->Backup_Path.empty())
472 printf(" Backup_Path: %s\n", Part->Backup_Path.c_str());
473 if (!Part->Backup_Name.empty())
474 printf(" Backup_Name: %s\n", Part->Backup_Name.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500475 if (!Part->Backup_Display_Name.empty())
476 printf(" Backup_Display_Name: %s\n", Part->Backup_Display_Name.c_str());
Gary Peck004d48b2012-11-21 16:28:18 -0800477 if (!Part->Backup_FileName.empty())
478 printf(" Backup_FileName: %s\n", Part->Backup_FileName.c_str());
479 if (!Part->Storage_Path.empty())
480 printf(" Storage_Path: %s\n", Part->Storage_Path.c_str());
481 if (!Part->Current_File_System.empty())
482 printf(" Current_File_System: %s\n", Part->Current_File_System.c_str());
483 if (!Part->Fstab_File_System.empty())
484 printf(" Fstab_File_System: %s\n", Part->Fstab_File_System.c_str());
485 if (Part->Format_Block_Size != 0)
Ethan Yonkerc798c9c2015-10-09 11:15:26 -0500486 printf(" Format_Block_Size: %lu\n", Part->Format_Block_Size);
Dees_Troy094207a2012-09-26 12:00:39 -0400487 if (!Part->MTD_Name.empty())
488 printf(" MTD_Name: %s\n", Part->MTD_Name.c_str());
Matt Mower029a82d2017-01-08 13:12:38 -0600489 printf(" Backup_Method: %s\n", Part->Backup_Method_By_Name().c_str());
Hashcode62bd9e02013-11-19 21:59:42 -0800490 if (Part->Mount_Flags || !Part->Mount_Options.empty())
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600491 printf(" Mount_Flags: %i, Mount_Options: %s\n", Part->Mount_Flags, Part->Mount_Options.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -0600492 if (Part->MTP_Storage_ID)
493 printf(" MTP_Storage_ID: %i\n", Part->MTP_Storage_ID);
Ethan Yonker93382822018-11-01 15:25:31 -0500494 if (!Part->Key_Directory.empty())
495 printf(" Metadata Key Directory: %s\n", Part->Key_Directory.c_str());
Ethan Yonker6277c792014-09-15 14:54:30 -0500496 printf("\n");
Dees_Troy8170a922012-09-18 15:40:25 -0400497}
498
Dees_Troy51a0e822012-09-05 15:24:24 -0400499int TWPartitionManager::Mount_By_Path(string Path, bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400500 std::vector<TWPartition*>::iterator iter;
501 int ret = false;
502 bool found = false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400503 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy5bf43922012-09-07 16:07:55 -0400504
Dees_Troyd93bda52013-07-03 19:55:19 +0000505 if (Local_Path == "/tmp" || Local_Path == "/")
Dees_Troy43d8b002012-09-17 16:00:01 -0400506 return true;
507
Dees_Troy5bf43922012-09-07 16:07:55 -0400508 // Iterate through all partitions
509 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -0400510 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400511 ret = (*iter)->Mount(Display_Error);
512 found = true;
Dees_Troy51127312012-09-08 13:08:49 -0400513 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400514 (*iter)->Mount(Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -0400515 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400516 }
517 if (found) {
518 return ret;
519 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500520 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Local_Path));
Dees_Troy5bf43922012-09-07 16:07:55 -0400521 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000522 LOGINFO("Mount: Unable to find partition for path '%s'\n", Local_Path.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400523 }
524 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400525}
526
Dees_Troy51a0e822012-09-05 15:24:24 -0400527int TWPartitionManager::UnMount_By_Path(string Path, bool Display_Error) {
Dees_Troy51127312012-09-08 13:08:49 -0400528 std::vector<TWPartition*>::iterator iter;
529 int ret = false;
530 bool found = false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400531 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy51127312012-09-08 13:08:49 -0400532
533 // Iterate through all partitions
534 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -0400535 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400536 ret = (*iter)->UnMount(Display_Error);
537 found = true;
538 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
539 (*iter)->UnMount(Display_Error);
540 }
541 }
542 if (found) {
543 return ret;
544 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500545 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Local_Path));
Dees_Troy51127312012-09-08 13:08:49 -0400546 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000547 LOGINFO("UnMount: Unable to find partition for path '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400548 }
549 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400550}
551
Dees_Troy51a0e822012-09-05 15:24:24 -0400552int TWPartitionManager::Is_Mounted_By_Path(string Path) {
Dees_Troy51127312012-09-08 13:08:49 -0400553 TWPartition* Part = Find_Partition_By_Path(Path);
554
555 if (Part)
556 return Part->Is_Mounted();
557 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000558 LOGINFO("Is_Mounted: Unable to find partition for path '%s'\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400559 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400560}
561
Dees_Troy5bf43922012-09-07 16:07:55 -0400562int TWPartitionManager::Mount_Current_Storage(bool Display_Error) {
Dees_Troy51127312012-09-08 13:08:49 -0400563 string current_storage_path = DataManager::GetCurrentStoragePath();
564
565 if (Mount_By_Path(current_storage_path, Display_Error)) {
566 TWPartition* FreeStorage = Find_Partition_By_Path(current_storage_path);
567 if (FreeStorage)
568 DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)(FreeStorage->Free / 1048576LLU));
569 return true;
570 }
571 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400572}
573
Dees_Troy5bf43922012-09-07 16:07:55 -0400574int TWPartitionManager::Mount_Settings_Storage(bool Display_Error) {
575 return Mount_By_Path(DataManager::GetSettingsStoragePath(), Display_Error);
576}
577
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600578TWPartition* TWPartitionManager::Find_Partition_By_Path(const string& Path) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400579 std::vector<TWPartition*>::iterator iter;
Dees_Troy38bd7602012-09-14 13:33:53 -0400580 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy5bf43922012-09-07 16:07:55 -0400581
582 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -0400583 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path))
Dees_Troy5bf43922012-09-07 16:07:55 -0400584 return (*iter);
585 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400586 return NULL;
587}
588
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600589TWPartition* TWPartitionManager::Find_Partition_By_Block_Device(const string& Block_Device) {
590 std::vector<TWPartition*>::iterator iter;
591
592 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
593 if ((*iter)->Primary_Block_Device == Block_Device || (!(*iter)->Actual_Block_Device.empty() && (*iter)->Actual_Block_Device == Block_Device))
594 return (*iter);
595 }
596 return NULL;
597}
598
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400599int TWPartitionManager::Check_Backup_Name(bool Display_Error) {
600 // Check the backup name to ensure that it is the correct size and contains only valid characters
601 // and that a backup with that name doesn't already exist
602 char backup_name[MAX_BACKUP_NAME_LEN];
603 char backup_loc[255], tw_image_dir[255];
604 int copy_size;
605 int index, cur_char;
606 string Backup_Name, Backup_Loc;
607
608 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
609 copy_size = Backup_Name.size();
610 // Check size
611 if (copy_size > MAX_BACKUP_NAME_LEN) {
612 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -0500613 gui_err("backup_name_len=Backup name is too long.");
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400614 return -2;
615 }
616
617 // Check each character
618 strncpy(backup_name, Backup_Name.c_str(), copy_size);
Dees_Troya13d74f2013-03-24 08:54:55 -0500619 if (copy_size == 1 && strncmp(backup_name, "0", 1) == 0)
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400620 return 0; // A "0" (zero) means to use the current timestamp for the backup name
621 for (index=0; index<copy_size; index++) {
622 cur_char = (int)backup_name[index];
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500623 if (cur_char == 32 || (cur_char >= 48 && cur_char <= 57) || (cur_char >= 65 && cur_char <= 91) || cur_char == 93 || cur_char == 95 || (cur_char >= 97 && cur_char <= 123) || cur_char == 125 || cur_char == 45 || cur_char == 46) {
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400624 // These are valid characters
625 // Numbers
626 // Upper case letters
627 // Lower case letters
628 // Space
629 // and -_.{}[]
630 } else {
631 if (Display_Error)
Ethan Yonker4adc33e2016-01-22 16:07:11 -0600632 gui_msg(Msg(msg::kError, "backup_name_invalid=Backup name '{1}' contains invalid character: '{1}'")(Backup_Name)((char)cur_char));
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400633 return -3;
634 }
635 }
636
637 // Check to make sure that a backup with this name doesn't already exist
638 DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, Backup_Loc);
639 strcpy(backup_loc, Backup_Loc.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500640 sprintf(tw_image_dir,"%s/%s", backup_loc, Backup_Name.c_str());
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500641 if (TWFunc::Path_Exists(tw_image_dir)) {
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400642 if (Display_Error)
Matt Mower3c366972015-12-25 19:28:31 -0600643 gui_err("backup_name_exists=A backup with that name already exists!");
bigbiffce8f83c2015-12-12 18:30:21 -0500644
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400645 return -4;
646 }
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400647 // No problems found, return 0
648 return 0;
649}
650
bigbiffce8f83c2015-12-12 18:30:21 -0500651bool TWPartitionManager::Backup_Partition(PartitionSettings *part_settings) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400652 time_t start, stop;
Matt Mower23d8aae2017-01-06 14:30:33 -0600653 int use_compression;
bigbiffce8f83c2015-12-12 18:30:21 -0500654 string backup_log = part_settings->Backup_Folder + "/recovery.log";
Dees_Troy43d8b002012-09-17 16:00:01 -0400655
bigbiffce8f83c2015-12-12 18:30:21 -0500656 if (part_settings->Part == NULL)
Dees_Troy43d8b002012-09-17 16:00:01 -0400657 return true;
658
Dees_Troy093b7642012-09-21 15:59:38 -0400659 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy093b7642012-09-21 15:59:38 -0400660
Tom Hite5a926722014-09-15 01:31:03 +0000661 TWFunc::SetPerformanceMode(true);
Dees_Troy43d8b002012-09-17 16:00:01 -0400662 time(&start);
663
bigbiffce8f83c2015-12-12 18:30:21 -0500664 if (part_settings->Part->Backup(part_settings, &tar_fork_pid)) {
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500665 sync();
666 sync();
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400667 string Full_Filename = part_settings->Backup_Folder + "/" + part_settings->Part->Backup_FileName;
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500668 if (!part_settings->adbbackup && part_settings->generate_digest) {
669 if (!twrpDigestDriver::Make_Digest(Full_Filename))
670 goto backup_error;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400671 }
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400672
bigbiffce8f83c2015-12-12 18:30:21 -0500673 if (part_settings->Part->Has_SubPartition) {
Dees_Troy8170a922012-09-18 15:40:25 -0400674 std::vector<TWPartition*>::iterator subpart;
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400675 TWPartition *parentPart = part_settings->Part;
Dees_Troy8170a922012-09-18 15:40:25 -0400676
677 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400678 if ((*subpart)->Can_Be_Backed_Up && (*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500679 part_settings->Part = *subpart;
bigbiffce8f83c2015-12-12 18:30:21 -0500680 if (!(*subpart)->Backup(part_settings, &tar_fork_pid)) {
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500681 goto backup_error;
Tom Hite5a926722014-09-15 01:31:03 +0000682 }
Dees_Troy2727b992013-08-14 20:09:30 +0000683 sync();
684 sync();
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400685 if (!part_settings->adbbackup && part_settings->generate_digest) {
686 if (!twrpDigestDriver::Make_Digest(Full_Filename)) {
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500687 goto backup_error;
bigbiffce8f83c2015-12-12 18:30:21 -0500688 }
Tom Hite5a926722014-09-15 01:31:03 +0000689 }
Dees_Troy8170a922012-09-18 15:40:25 -0400690 }
691 }
692 }
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400693
Dees_Troy43d8b002012-09-17 16:00:01 -0400694 time(&stop);
that203bcc92015-05-09 17:27:33 +0200695 int backup_time = (int) difftime(stop, start);
Dees_Troy2673cec2013-04-02 20:22:16 +0000696 LOGINFO("Partition Backup time: %d\n", backup_time);
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400697
bigbiffce8f83c2015-12-12 18:30:21 -0500698 if (part_settings->Part->Backup_Method == BM_FILES) {
699 part_settings->file_time += backup_time;
Dees_Troy43d8b002012-09-17 16:00:01 -0400700 } else {
bigbiffce8f83c2015-12-12 18:30:21 -0500701 part_settings->img_time += backup_time;
702
Dees_Troy43d8b002012-09-17 16:00:01 -0400703 }
Tom Hite5a926722014-09-15 01:31:03 +0000704
Matt Mower02899552016-12-30 18:13:51 -0600705 TWFunc::SetPerformanceMode(false);
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500706 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -0400707 }
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500708backup_error:
709 Clean_Backup_Folder(part_settings->Backup_Folder);
710 TWFunc::copy_file("/tmp/recovery.log", backup_log, 0644);
711 tw_set_default_metadata(backup_log.c_str());
712 TWFunc::SetPerformanceMode(false);
713 return false;
bigbiff7abc5fe2015-01-17 16:53:12 -0500714}
715
bigbiffbf1d6722015-02-14 16:25:59 -0500716void TWPartitionManager::Clean_Backup_Folder(string Backup_Folder) {
717 DIR *d = opendir(Backup_Folder.c_str());
718 struct dirent *p;
719 int r;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400720 vector<string> ext;
721
722 //extensions we should delete when cleaning
723 ext.push_back("win");
724 ext.push_back("md5");
725 ext.push_back("sha2");
726 ext.push_back("info");
bigbiffbf1d6722015-02-14 16:25:59 -0500727
Ethan Yonker74db1572015-10-28 12:44:49 -0500728 gui_msg("backup_clean=Backup Failed. Cleaning Backup Folder.");
bigbiffbf1d6722015-02-14 16:25:59 -0500729
730 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500731 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Backup_Folder)(strerror(errno)));
bigbiffbf1d6722015-02-14 16:25:59 -0500732 return;
733 }
734
Matt Mower2b18a532015-02-20 16:58:05 -0600735 while ((p = readdir(d))) {
bigbiffbf1d6722015-02-14 16:25:59 -0500736 if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
737 continue;
738
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500739 string path = Backup_Folder + "/" + p->d_name;
bigbiffbf1d6722015-02-14 16:25:59 -0500740
741 size_t dot = path.find_last_of(".") + 1;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400742 for (vector<string>::const_iterator i = ext.begin(); i != ext.end(); ++i) {
743 if (path.substr(dot) == *i) {
744 r = unlink(path.c_str());
745 if (r != 0)
746 LOGINFO("Unable to unlink '%s: %s'\n", path.c_str(), strerror(errno));
bigbiffbf1d6722015-02-14 16:25:59 -0500747 }
748 }
749 }
750 closedir(d);
751}
752
Ethan Yonker472f5062016-02-25 13:47:30 -0600753int TWPartitionManager::Check_Backup_Cancel() {
754 return stop_backup.get_value();
755}
756
bigbiff7abc5fe2015-01-17 16:53:12 -0500757int TWPartitionManager::Cancel_Backup() {
758 string Backup_Folder, Backup_Name, Full_Backup_Path;
759
760 stop_backup.set_value(1);
761
762 if (tar_fork_pid != 0) {
763 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
764 DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, Backup_Folder);
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500765 Full_Backup_Path = Backup_Folder + "/" + Backup_Name;
bigbiff7abc5fe2015-01-17 16:53:12 -0500766 LOGINFO("Killing pid: %d\n", tar_fork_pid);
767 kill(tar_fork_pid, SIGUSR2);
768 while (kill(tar_fork_pid, 0) == 0) {
769 usleep(1000);
770 }
771 LOGINFO("Backup_Run stopped and returning false, backup cancelled.\n");
772 LOGINFO("Removing directory %s\n", Full_Backup_Path.c_str());
773 TWFunc::removeDir(Full_Backup_Path, false);
774 tar_fork_pid = 0;
775 }
776
777 return 0;
Dees_Troy43d8b002012-09-17 16:00:01 -0400778}
779
bigbiffce8f83c2015-12-12 18:30:21 -0500780int TWPartitionManager::Run_Backup(bool adbbackup) {
781 PartitionSettings part_settings;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400782 int partition_count = 0, disable_free_space_check = 0, skip_digest = 0;
bigbiffce8f83c2015-12-12 18:30:21 -0500783 string Backup_Name, Backup_List, backup_path;
Matt Mower23d8aae2017-01-06 14:30:33 -0600784 unsigned long long total_bytes = 0, free_space = 0;
Dees_Troy43d8b002012-09-17 16:00:01 -0400785 TWPartition* storage = NULL;
Dees_Troy8170a922012-09-18 15:40:25 -0400786 std::vector<TWPartition*>::iterator subpart;
Dees_Troy43d8b002012-09-17 16:00:01 -0400787 struct tm *t;
Matt Mower23d8aae2017-01-06 14:30:33 -0600788 time_t seconds, total_start, total_stop;
Dees_Troya13d74f2013-03-24 08:54:55 -0500789 size_t start_pos = 0, end_pos = 0;
bigbiff7abc5fe2015-01-17 16:53:12 -0500790 stop_backup.set_value(0);
Dees_Troy43d8b002012-09-17 16:00:01 -0400791 seconds = time(0);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500792 t = localtime(&seconds);
Dees_Troy43d8b002012-09-17 16:00:01 -0400793
bigbiffce8f83c2015-12-12 18:30:21 -0500794 part_settings.img_bytes_remaining = 0;
795 part_settings.file_bytes_remaining = 0;
796 part_settings.img_time = 0;
797 part_settings.file_time = 0;
798 part_settings.img_bytes = 0;
799 part_settings.file_bytes = 0;
800 part_settings.PM_Method = PM_BACKUP;
801
bigbiffce8f83c2015-12-12 18:30:21 -0500802 part_settings.adbbackup = adbbackup;
Dees_Troy43d8b002012-09-17 16:00:01 -0400803 time(&total_start);
804
805 Update_System_Details();
806
807 if (!Mount_Current_Storage(true))
808 return false;
809
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400810 DataManager::GetValue(TW_SKIP_DIGEST_GENERATE_VAR, skip_digest);
811 if (skip_digest == 0)
812 part_settings.generate_digest = true;
Dees_Troyc5865ab2012-09-24 15:08:04 -0400813 else
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400814 part_settings.generate_digest = false;
Dees_Troy4a2a1262012-09-18 09:33:47 -0400815
bigbiffce8f83c2015-12-12 18:30:21 -0500816 DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, part_settings.Backup_Folder);
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500817 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
818 if (Backup_Name == gui_lookup("curr_date", "(Current Date)")) {
819 Backup_Name = TWFunc::Get_Current_Date();
820 } else if (Backup_Name == gui_lookup("auto_generate", "(Auto Generate)") || Backup_Name == "0" || Backup_Name.empty()) {
Dees Troyb21cc642013-09-10 17:36:41 +0000821 TWFunc::Auto_Generate_Backup_Name();
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500822 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
Dees_Troy43d8b002012-09-17 16:00:01 -0400823 }
bigbiffce8f83c2015-12-12 18:30:21 -0500824
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500825 LOGINFO("Backup Name is: '%s'\n", Backup_Name.c_str());
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500826 part_settings.Backup_Folder = part_settings.Backup_Folder + "/" + Backup_Name;
bigbiffce8f83c2015-12-12 18:30:21 -0500827
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500828 LOGINFO("Backup_Folder is: '%s'\n", part_settings.Backup_Folder.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -0400829
Dees_Troy2673cec2013-04-02 20:22:16 +0000830 LOGINFO("Calculating backup details...\n");
Dees_Troya13d74f2013-03-24 08:54:55 -0500831 DataManager::GetValue("tw_backup_list", Backup_List);
832 if (!Backup_List.empty()) {
833 end_pos = Backup_List.find(";", start_pos);
834 while (end_pos != string::npos && start_pos < Backup_List.size()) {
835 backup_path = Backup_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -0500836 part_settings.Part = Find_Partition_By_Path(backup_path);
837 if (part_settings.Part != NULL) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500838 partition_count++;
bigbiffce8f83c2015-12-12 18:30:21 -0500839 if (part_settings.Part->Backup_Method == BM_FILES)
840 part_settings.file_bytes += part_settings.Part->Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -0500841 else
bigbiffce8f83c2015-12-12 18:30:21 -0500842 part_settings.img_bytes += part_settings.Part->Backup_Size;
843 if (part_settings.Part->Has_SubPartition) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500844 std::vector<TWPartition*>::iterator subpart;
845
846 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiffce8f83c2015-12-12 18:30:21 -0500847 if ((*subpart)->Can_Be_Backed_Up && (*subpart)->Is_Present && (*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == part_settings.Part->Mount_Point) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500848 partition_count++;
bigbiffce8f83c2015-12-12 18:30:21 -0500849 if ((*subpart)->Backup_Method == BM_FILES)
850 part_settings.file_bytes += (*subpart)->Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -0500851 else
bigbiffce8f83c2015-12-12 18:30:21 -0500852 part_settings.img_bytes += (*subpart)->Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -0500853 }
854 }
Dees_Troy8170a922012-09-18 15:40:25 -0400855 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500856 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500857 gui_msg(Msg(msg::kError, "unable_to_locate_partition=Unable to locate '{1}' partition for backup calculations.")(backup_path));
Dees_Troy8170a922012-09-18 15:40:25 -0400858 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500859 start_pos = end_pos + 1;
860 end_pos = Backup_List.find(";", start_pos);
Dees_Troy43d8b002012-09-17 16:00:01 -0400861 }
862 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400863
864 if (partition_count == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500865 gui_msg("no_partition_selected=No partitions selected for backup.");
Dees_Troy43d8b002012-09-17 16:00:01 -0400866 return false;
867 }
bigbiffce8f83c2015-12-12 18:30:21 -0500868 if (adbbackup) {
869 if (twadbbu::Write_ADB_Stream_Header(partition_count) == false) {
870 return false;
871 }
872 }
873 total_bytes = part_settings.file_bytes + part_settings.img_bytes;
Ethan Yonker472f5062016-02-25 13:47:30 -0600874 ProgressTracking progress(total_bytes);
bigbiffce8f83c2015-12-12 18:30:21 -0500875 part_settings.progress = &progress;
876
Ethan Yonker74db1572015-10-28 12:44:49 -0500877 gui_msg(Msg("total_partitions_backup= * Total number of partitions to back up: {1}")(partition_count));
878 gui_msg(Msg("total_backup_size= * Total size of all data: {1}MB")(total_bytes / 1024 / 1024));
Dees_Troy43d8b002012-09-17 16:00:01 -0400879 storage = Find_Partition_By_Path(DataManager::GetCurrentStoragePath());
880 if (storage != NULL) {
881 free_space = storage->Free;
Ethan Yonker74db1572015-10-28 12:44:49 -0500882 gui_msg(Msg("available_space= * Available space: {1}MB")(free_space / 1024 / 1024));
Dees_Troy43d8b002012-09-17 16:00:01 -0400883 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500884 gui_err("unable_locate_storage=Unable to locate storage device.");
Dees_Troy43d8b002012-09-17 16:00:01 -0400885 return false;
886 }
bigbiffbf1d6722015-02-14 16:25:59 -0500887
Matt Mowerbfccfb82016-04-25 23:22:31 -0500888 DataManager::GetValue(TW_DISABLE_FREE_SPACE_VAR, disable_free_space_check);
bigbiffce8f83c2015-12-12 18:30:21 -0500889
890 if (adbbackup)
891 disable_free_space_check = true;
892
bigbiffbf1d6722015-02-14 16:25:59 -0500893 if (!disable_free_space_check) {
894 if (free_space - (32 * 1024 * 1024) < total_bytes) {
895 // We require an extra 32MB just in case
Ethan Yonker74db1572015-10-28 12:44:49 -0500896 gui_err("no_space=Not enough free space on storage.");
bigbiffbf1d6722015-02-14 16:25:59 -0500897 return false;
898 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400899 }
bigbiffce8f83c2015-12-12 18:30:21 -0500900 part_settings.img_bytes_remaining = part_settings.img_bytes;
901 part_settings.file_bytes_remaining = part_settings.file_bytes;
Dees_Troy43d8b002012-09-17 16:00:01 -0400902
Ethan Yonker74db1572015-10-28 12:44:49 -0500903 gui_msg("backup_started=[BACKUP STARTED]");
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500904 gui_msg(Msg("backup_folder= * Backup Folder: {1}")(part_settings.Backup_Folder));
905 if (!TWFunc::Recursive_Mkdir(part_settings.Backup_Folder)) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500906 gui_err("fail_backup_folder=Failed to make backup folder.");
Dees_Troyd4b22b02013-01-18 17:17:58 +0000907 return false;
908 }
909
Dees_Troy2673cec2013-04-02 20:22:16 +0000910 DataManager::SetProgress(0.0);
Dees_Troy093b7642012-09-21 15:59:38 -0400911
Dees_Troya13d74f2013-03-24 08:54:55 -0500912 start_pos = 0;
913 end_pos = Backup_List.find(";", start_pos);
914 while (end_pos != string::npos && start_pos < Backup_List.size()) {
bigbiff7abc5fe2015-01-17 16:53:12 -0500915 if (stop_backup.get_value() != 0)
916 return -1;
Dees_Troya13d74f2013-03-24 08:54:55 -0500917 backup_path = Backup_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -0500918 part_settings.Part = Find_Partition_By_Path(backup_path);
919 if (part_settings.Part != NULL) {
920 if (!Backup_Partition(&part_settings))
Dees_Troya13d74f2013-03-24 08:54:55 -0500921 return false;
922 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500923 gui_msg(Msg(msg::kError, "unable_to_locate_partition=Unable to locate '{1}' partition for backup calculations.")(backup_path));
Dees_Troya13d74f2013-03-24 08:54:55 -0500924 }
925 start_pos = end_pos + 1;
926 end_pos = Backup_List.find(";", start_pos);
927 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400928
929 // Average BPS
bigbiffce8f83c2015-12-12 18:30:21 -0500930 if (part_settings.img_time == 0)
931 part_settings.img_time = 1;
932 if (part_settings.file_time == 0)
933 part_settings.file_time = 1;
934 int img_bps = (int)part_settings.img_bytes / (int)part_settings.img_time;
935 unsigned long long file_bps = part_settings.file_bytes / (int)part_settings.file_time;
Dees_Troy43d8b002012-09-17 16:00:01 -0400936
bigbiffce8f83c2015-12-12 18:30:21 -0500937 if (part_settings.file_bytes != 0)
Ethan Yonker472f5062016-02-25 13:47:30 -0600938 gui_msg(Msg("avg_backup_fs=Average backup rate for file systems: {1} MB/sec")(file_bps / (1024 * 1024)));
bigbiffce8f83c2015-12-12 18:30:21 -0500939 if (part_settings.img_bytes != 0)
Ethan Yonker472f5062016-02-25 13:47:30 -0600940 gui_msg(Msg("avg_backup_img=Average backup rate for imaged drives: {1} MB/sec")(img_bps / (1024 * 1024)));
Dees_Troy43d8b002012-09-17 16:00:01 -0400941
942 time(&total_stop);
943 int total_time = (int) difftime(total_stop, total_start);
bigbiffce8f83c2015-12-12 18:30:21 -0500944
945 uint64_t actual_backup_size;
Ethan Yonker3fdcda42016-11-30 12:29:37 -0600946 if (!adbbackup) {
947 TWExclude twe;
948 actual_backup_size = twe.Get_Folder_Size(part_settings.Backup_Folder);
949 } else
bigbiffce8f83c2015-12-12 18:30:21 -0500950 actual_backup_size = part_settings.file_bytes + part_settings.img_bytes;
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500951 actual_backup_size /= (1024LLU * 1024LLU);
Dees_Troy43d8b002012-09-17 16:00:01 -0400952
bigbiffce8f83c2015-12-12 18:30:21 -0500953 int prev_img_bps = 0, use_compression = 0;
954 unsigned long long prev_file_bps = 0;
Matt Mower173cdb92016-12-31 02:49:19 -0600955 DataManager::GetValue(TW_BACKUP_AVG_IMG_RATE, prev_img_bps);
Dees_Troy093b7642012-09-21 15:59:38 -0400956 img_bps += (prev_img_bps * 4);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500957 img_bps /= 5;
Dees_Troy093b7642012-09-21 15:59:38 -0400958
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500959 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy093b7642012-09-21 15:59:38 -0400960 if (use_compression)
961 DataManager::GetValue(TW_BACKUP_AVG_FILE_COMP_RATE, prev_file_bps);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500962 else
Dees_Troy093b7642012-09-21 15:59:38 -0400963 DataManager::GetValue(TW_BACKUP_AVG_FILE_RATE, prev_file_bps);
964 file_bps += (prev_file_bps * 4);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500965 file_bps /= 5;
Dees_Troy093b7642012-09-21 15:59:38 -0400966
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500967 DataManager::SetValue(TW_BACKUP_AVG_IMG_RATE, img_bps);
Dees_Troy093b7642012-09-21 15:59:38 -0400968 if (use_compression)
969 DataManager::SetValue(TW_BACKUP_AVG_FILE_COMP_RATE, file_bps);
970 else
971 DataManager::SetValue(TW_BACKUP_AVG_FILE_RATE, file_bps);
972
Ethan Yonker74db1572015-10-28 12:44:49 -0500973 gui_msg(Msg("total_backed_size=[{1} MB TOTAL BACKED UP]")(actual_backup_size));
Dees_Troy43d8b002012-09-17 16:00:01 -0400974 Update_System_Details();
Dees_Troyd0384ef2012-10-12 12:15:42 -0400975 UnMount_Main_Partitions();
Ethan Yonker56db1c42015-12-20 22:49:00 -0600976 gui_msg(Msg(msg::kHighlight, "backup_completed=[BACKUP COMPLETED IN {1} SECONDS]")(total_time)); // the end
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500977 string backup_log = part_settings.Backup_Folder + "/recovery.log";
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000978 TWFunc::copy_file("/tmp/recovery.log", backup_log, 0644);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600979 tw_set_default_metadata(backup_log.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -0500980
981 if (part_settings.adbbackup) {
982 if (twadbbu::Write_ADB_Stream_Trailer() == false) {
983 return false;
984 }
985 }
986 part_settings.adbbackup = false;
987 DataManager::SetValue("tw_enable_adb_backup", 0);
988
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000989 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400990}
991
bigbiffce8f83c2015-12-12 18:30:21 -0500992bool TWPartitionManager::Restore_Partition(PartitionSettings *part_settings) {
Dees_Troy4a2a1262012-09-18 09:33:47 -0400993 time_t Start, Stop;
bigbiffce8f83c2015-12-12 18:30:21 -0500994
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -0400995 if (part_settings->adbbackup) {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400996 std::string partName = part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win";
997 LOGINFO("setting backup name: %s\n", partName.c_str());
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -0400998 part_settings->Part->Set_Backup_FileName(part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win");
999 }
1000
Tom Hite5a926722014-09-15 01:31:03 +00001001 TWFunc::SetPerformanceMode(true);
bigbiffce8f83c2015-12-12 18:30:21 -05001002
Dees_Troy4a2a1262012-09-18 09:33:47 -04001003 time(&Start);
Ethan Yonker472f5062016-02-25 13:47:30 -06001004
bigbiffce8f83c2015-12-12 18:30:21 -05001005 if (!part_settings->Part->Restore(part_settings)) {
Tom Hite5a926722014-09-15 01:31:03 +00001006 TWFunc::SetPerformanceMode(false);
Dees_Troy4a2a1262012-09-18 09:33:47 -04001007 return false;
Tom Hite5a926722014-09-15 01:31:03 +00001008 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001009 if (part_settings->Part->Has_SubPartition && !part_settings->adbbackup) {
Dees_Troy8170a922012-09-18 15:40:25 -04001010 std::vector<TWPartition*>::iterator subpart;
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -04001011 TWPartition *parentPart = part_settings->Part;
Dees_Troy8170a922012-09-18 15:40:25 -04001012
1013 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -04001014 part_settings->Part = *subpart;
1015 if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) {
1016 part_settings->Part = (*subpart);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001017 part_settings->Part->Set_Backup_FileName(part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win");
bigbiffce8f83c2015-12-12 18:30:21 -05001018 if (!(*subpart)->Restore(part_settings)) {
Tom Hite5a926722014-09-15 01:31:03 +00001019 TWFunc::SetPerformanceMode(false);
Dees_Troy8170a922012-09-18 15:40:25 -04001020 return false;
Tom Hite5a926722014-09-15 01:31:03 +00001021 }
Dees_Troy8170a922012-09-18 15:40:25 -04001022 }
1023 }
1024 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001025 time(&Stop);
Tom Hite5a926722014-09-15 01:31:03 +00001026 TWFunc::SetPerformanceMode(false);
bigbiffce8f83c2015-12-12 18:30:21 -05001027 gui_msg(Msg("restore_part_done=[{1} done ({2} seconds)]")(part_settings->Part->Backup_Display_Name)((int)difftime(Stop, Start)));
1028
Dees_Troy4a2a1262012-09-18 09:33:47 -04001029 return true;
1030}
1031
Ethan Yonker472f5062016-02-25 13:47:30 -06001032int TWPartitionManager::Run_Restore(const string& Restore_Name) {
bigbiffce8f83c2015-12-12 18:30:21 -05001033 PartitionSettings part_settings;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001034 int check_digest;
bigbiffce8f83c2015-12-12 18:30:21 -05001035
Dees_Troy4a2a1262012-09-18 09:33:47 -04001036 time_t rStart, rStop;
1037 time(&rStart);
Dees_Troya13d74f2013-03-24 08:54:55 -05001038 string Restore_List, restore_path;
1039 size_t start_pos = 0, end_pos;
bigbiffce8f83c2015-12-12 18:30:21 -05001040
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001041 part_settings.Backup_Folder = Restore_Name;
bigbiffce8f83c2015-12-12 18:30:21 -05001042 part_settings.Part = NULL;
1043 part_settings.partition_count = 0;
1044 part_settings.total_restore_size = 0;
1045 part_settings.adbbackup = false;
1046 part_settings.PM_Method = PM_RESTORE;
Dees_Troy43d8b002012-09-17 16:00:01 -04001047
Ethan Yonker74db1572015-10-28 12:44:49 -05001048 gui_msg("restore_started=[RESTORE STARTED]");
1049 gui_msg(Msg("restore_folder=Restore folder: '{1}'")(Restore_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04001050
Dees_Troy4a2a1262012-09-18 09:33:47 -04001051 if (!Mount_Current_Storage(true))
1052 return false;
1053
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001054 DataManager::GetValue(TW_SKIP_DIGEST_CHECK_VAR, check_digest);
1055 if (check_digest > 0) {
1056 // Check Digest files first before restoring to ensure that all of them match before starting a restore
1057 TWFunc::GUI_Operation_Text(TW_VERIFY_DIGEST_TEXT, gui_parse_text("{@verifying_digest}"));
1058 gui_msg("verifying_digest=Verifying Digest");
Dees_Troya13d74f2013-03-24 08:54:55 -05001059 } else {
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001060 gui_msg("skip_digest=Skipping Digest check based on user setting.");
Dees_Troya13d74f2013-03-24 08:54:55 -05001061 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001062 gui_msg("calc_restore=Calculating restore details...");
Dees_Troya13d74f2013-03-24 08:54:55 -05001063 DataManager::GetValue("tw_restore_selected", Restore_List);
bigbiffce8f83c2015-12-12 18:30:21 -05001064
Dees_Troya13d74f2013-03-24 08:54:55 -05001065 if (!Restore_List.empty()) {
1066 end_pos = Restore_List.find(";", start_pos);
1067 while (end_pos != string::npos && start_pos < Restore_List.size()) {
1068 restore_path = Restore_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -05001069 part_settings.Part = Find_Partition_By_Path(restore_path);
1070 if (part_settings.Part != NULL) {
bigbiffce8f83c2015-12-12 18:30:21 -05001071 if (part_settings.Part->Mount_Read_Only) {
1072 gui_msg(Msg(msg::kError, "restore_read_only=Cannot restore {1} -- mounted read only.")(part_settings.Part->Backup_Display_Name));
Ethan Yonkereb32b1f2015-05-18 10:23:03 -05001073 return false;
1074 }
bigbiffce8f83c2015-12-12 18:30:21 -05001075
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001076 string Full_Filename = part_settings.Backup_Folder + "/" + part_settings.Part->Backup_FileName;
1077
1078 if (check_digest > 0 && !twrpDigestDriver::Check_Digest(Full_Filename))
Dees_Troya13d74f2013-03-24 08:54:55 -05001079 return false;
bigbiffce8f83c2015-12-12 18:30:21 -05001080 part_settings.partition_count++;
1081 part_settings.total_restore_size += part_settings.Part->Get_Restore_Size(&part_settings);
1082 if (part_settings.Part->Has_SubPartition) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -04001083 TWPartition *parentPart = part_settings.Part;
Dees_Troya13d74f2013-03-24 08:54:55 -05001084 std::vector<TWPartition*>::iterator subpart;
1085
1086 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -04001087 part_settings.Part = *subpart;
1088 if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) {
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001089 if (check_digest > 0 && !twrpDigestDriver::Check_Digest(Full_Filename))
Dees_Troya13d74f2013-03-24 08:54:55 -05001090 return false;
bigbiffce8f83c2015-12-12 18:30:21 -05001091 part_settings.total_restore_size += (*subpart)->Get_Restore_Size(&part_settings);
Dees_Troya13d74f2013-03-24 08:54:55 -05001092 }
1093 }
1094 }
1095 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001096 gui_msg(Msg(msg::kError, "restore_unable_locate=Unable to locate '{1}' partition for restoring.")(restore_path));
Dees_Troya13d74f2013-03-24 08:54:55 -05001097 }
1098 start_pos = end_pos + 1;
1099 end_pos = Restore_List.find(";", start_pos);
Dees_Troy4a2a1262012-09-18 09:33:47 -04001100 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001101 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001102
bigbiffce8f83c2015-12-12 18:30:21 -05001103 if (part_settings.partition_count == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001104 gui_err("no_part_restore=No partitions selected for restore.");
Dees_Troy4a2a1262012-09-18 09:33:47 -04001105 return false;
1106 }
1107
bigbiffce8f83c2015-12-12 18:30:21 -05001108 gui_msg(Msg("restore_part_count=Restoring {1} partitions...")(part_settings.partition_count));
1109 gui_msg(Msg("total_restore_size=Total restore size is {1}MB")(part_settings.total_restore_size / 1048576));
Dees_Troy2673cec2013-04-02 20:22:16 +00001110 DataManager::SetProgress(0.0);
bigbiffce8f83c2015-12-12 18:30:21 -05001111 ProgressTracking progress(part_settings.total_restore_size);
1112 part_settings.progress = &progress;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001113
Dees_Troya13d74f2013-03-24 08:54:55 -05001114 start_pos = 0;
1115 if (!Restore_List.empty()) {
1116 end_pos = Restore_List.find(";", start_pos);
1117 while (end_pos != string::npos && start_pos < Restore_List.size()) {
1118 restore_path = Restore_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -05001119
1120 part_settings.Part = Find_Partition_By_Path(restore_path);
1121 if (part_settings.Part != NULL) {
1122 part_settings.partition_count++;
bigbiffce8f83c2015-12-12 18:30:21 -05001123 if (!Restore_Partition(&part_settings))
Dees_Troya13d74f2013-03-24 08:54:55 -05001124 return false;
1125 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001126 gui_msg(Msg(msg::kError, "restore_unable_locate=Unable to locate '{1}' partition for restoring.")(restore_path));
Dees_Troya13d74f2013-03-24 08:54:55 -05001127 }
1128 start_pos = end_pos + 1;
1129 end_pos = Restore_List.find(";", start_pos);
1130 }
1131 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001132 TWFunc::GUI_Operation_Text(TW_UPDATE_SYSTEM_DETAILS_TEXT, gui_parse_text("{@updating_system_details}"));
Captain Throwback9d6feb52018-07-27 10:05:24 -04001133 UnMount_By_Path(Get_Android_Root_Path(), false);
Dees_Troy43d8b002012-09-17 16:00:01 -04001134 Update_System_Details();
Dees_Troyd0384ef2012-10-12 12:15:42 -04001135 UnMount_Main_Partitions();
Dees_Troy4a2a1262012-09-18 09:33:47 -04001136 time(&rStop);
Matt Mower3c366972015-12-25 19:28:31 -06001137 gui_msg(Msg(msg::kHighlight, "restore_completed=[RESTORE COMPLETED IN {1} SECONDS]")((int)difftime(rStop,rStart)));
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001138 DataManager::SetValue("tw_file_progress", "");
bigbiffce8f83c2015-12-12 18:30:21 -05001139
Dees_Troy63c8df72012-09-10 14:02:05 -04001140 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001141}
1142
1143void TWPartitionManager::Set_Restore_Files(string Restore_Name) {
Dees_Troy63c8df72012-09-10 14:02:05 -04001144 // Start with the default values
Dees_Troya13d74f2013-03-24 08:54:55 -05001145 string Restore_List;
Dees_Troy83bd4832013-05-04 12:39:56 +00001146 bool get_date = true, check_encryption = true;
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001147 bool adbbackup = false;
Dees_Troy83bd4832013-05-04 12:39:56 +00001148
1149 DataManager::SetValue("tw_restore_encrypted", 0);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001150 if (twadbbu::Check_ADB_Backup_File(Restore_Name)) {
1151 vector<string> adb_files;
1152 adb_files = twadbbu::Get_ADB_Backup_Files(Restore_Name);
1153 for (unsigned int i = 0; i < adb_files.size(); ++i) {
1154 string adb_restore_file = adb_files.at(i);
1155 std::size_t pos = adb_restore_file.find_first_of(".");
1156 std::string path = "/" + adb_restore_file.substr(0, pos);
1157 Restore_List = path + ";";
1158 TWPartition* Part = Find_Partition_By_Path(path);
1159 Part->Backup_FileName = TWFunc::Get_Filename(adb_restore_file);
1160 adbbackup = true;
1161 }
1162 DataManager::SetValue("tw_enable_adb_backup", 1);
Dees_Troy63c8df72012-09-10 14:02:05 -04001163 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001164 else {
1165 DIR* d;
1166 d = opendir(Restore_Name.c_str());
1167 if (d == NULL)
Dees_Troy63c8df72012-09-10 14:02:05 -04001168 {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001169 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Name)(strerror(errno)));
1170 return;
Dees_Troy63c8df72012-09-10 14:02:05 -04001171 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001172
1173 struct dirent* de;
1174 while ((de = readdir(d)) != NULL)
Dees_Troy63c8df72012-09-10 14:02:05 -04001175 {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001176 // Strip off three components
1177 char str[256];
1178 char* label;
1179 char* fstype = NULL;
1180 char* extn = NULL;
1181 char* ptr;
Dees_Troy63c8df72012-09-10 14:02:05 -04001182
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001183 strcpy(str, de->d_name);
1184 if (strlen(str) <= 2)
1185 continue;
Dees_Troy83bd4832013-05-04 12:39:56 +00001186
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001187 if (get_date) {
1188 char file_path[255];
1189 struct stat st;
1190
1191 strcpy(file_path, Restore_Name.c_str());
1192 strcat(file_path, "/");
1193 strcat(file_path, str);
1194 stat(file_path, &st);
1195 string backup_date = ctime((const time_t*)(&st.st_mtime));
1196 DataManager::SetValue(TW_RESTORE_FILE_DATE, backup_date);
1197 get_date = false;
Dees_Troy83bd4832013-05-04 12:39:56 +00001198 }
Dees_Troy63c8df72012-09-10 14:02:05 -04001199
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001200 label = str;
1201 ptr = label;
1202 while (*ptr && *ptr != '.') ptr++;
1203 if (*ptr == '.')
1204 {
1205 *ptr = 0x00;
1206 ptr++;
1207 fstype = ptr;
1208 }
1209 while (*ptr && *ptr != '.') ptr++;
1210 if (*ptr == '.')
1211 {
1212 *ptr = 0x00;
1213 ptr++;
1214 extn = ptr;
1215 }
Dees_Troy63c8df72012-09-10 14:02:05 -04001216
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001217 if (fstype == NULL || extn == NULL || strcmp(fstype, "log") == 0) continue;
1218 int extnlength = strlen(extn);
1219 if (extnlength != 3 && extnlength != 6) continue;
1220 if (extnlength >= 3 && strncmp(extn, "win", 3) != 0) continue;
1221 //if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue;
Dees_Troy63c8df72012-09-10 14:02:05 -04001222
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001223 if (check_encryption) {
1224 string filename = Restore_Name + "/";
1225 filename += de->d_name;
1226 if (TWFunc::Get_File_Type(filename) == 2) {
1227 LOGINFO("'%s' is encrypted\n", filename.c_str());
1228 DataManager::SetValue("tw_restore_encrypted", 1);
1229 }
1230 }
1231 if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue;
1232
1233 TWPartition* Part = Find_Partition_By_Path(label);
1234 if (Part == NULL)
1235 {
1236 gui_msg(Msg(msg::kError, "unable_locate_part_backup_name=Unable to locate partition by backup name: '{1}'")(label));
1237 continue;
1238 }
1239
1240 Part->Backup_FileName = de->d_name;
1241 if (strlen(extn) > 3) {
1242 Part->Backup_FileName.resize(Part->Backup_FileName.size() - strlen(extn) + 3);
1243 }
1244
1245 if (!Part->Is_SubPartition)
1246 Restore_List += Part->Backup_Path + ";";
1247 }
1248 closedir(d);
Dees_Troy63c8df72012-09-10 14:02:05 -04001249 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001250
1251 if (adbbackup) {
1252 Restore_List = "ADB_Backup;";
1253 adbbackup = false;
1254 }
Dees_Troy63c8df72012-09-10 14:02:05 -04001255
Dees_Troya13d74f2013-03-24 08:54:55 -05001256 // Set the final value
1257 DataManager::SetValue("tw_restore_list", Restore_List);
1258 DataManager::SetValue("tw_restore_selected", Restore_List);
Dees_Troy51a0e822012-09-05 15:24:24 -04001259 return;
1260}
1261
1262int TWPartitionManager::Wipe_By_Path(string Path) {
Dees_Troy63c8df72012-09-10 14:02:05 -04001263 std::vector<TWPartition*>::iterator iter;
1264 int ret = false;
1265 bool found = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04001266 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy63c8df72012-09-10 14:02:05 -04001267
1268 // Iterate through all partitions
1269 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -04001270 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
Dees_Troye58d5262012-09-21 12:27:57 -04001271 if (Path == "/and-sec")
1272 ret = (*iter)->Wipe_AndSec();
1273 else
1274 ret = (*iter)->Wipe();
Dees_Troy63c8df72012-09-10 14:02:05 -04001275 found = true;
1276 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1277 (*iter)->Wipe();
1278 }
1279 }
1280 if (found) {
1281 return ret;
1282 } else
Ethan Yonker74db1572015-10-28 12:44:49 -05001283 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Local_Path));
Dees_Troy63c8df72012-09-10 14:02:05 -04001284 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001285}
1286
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001287int TWPartitionManager::Wipe_By_Path(string Path, string New_File_System) {
1288 std::vector<TWPartition*>::iterator iter;
1289 int ret = false;
1290 bool found = false;
1291 string Local_Path = TWFunc::Get_Root_Path(Path);
1292
1293 // Iterate through all partitions
1294 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1295 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
1296 if (Path == "/and-sec")
1297 ret = (*iter)->Wipe_AndSec();
1298 else
1299 ret = (*iter)->Wipe(New_File_System);
1300 found = true;
1301 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1302 (*iter)->Wipe(New_File_System);
1303 }
1304 }
1305 if (found) {
1306 return ret;
1307 } else
Ethan Yonker74db1572015-10-28 12:44:49 -05001308 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Local_Path));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001309 return false;
1310}
1311
Dees_Troy51a0e822012-09-05 15:24:24 -04001312int TWPartitionManager::Factory_Reset(void) {
Dees_Troy63c8df72012-09-10 14:02:05 -04001313 std::vector<TWPartition*>::iterator iter;
1314 int ret = true;
1315
1316 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001317 if ((*iter)->Wipe_During_Factory_Reset && (*iter)->Is_Present) {
Ethan Yonker89583ef2015-08-26 09:01:59 -05001318#ifdef TW_OEM_BUILD
1319 if ((*iter)->Mount_Point == "/data") {
1320 if (!(*iter)->Wipe_Encryption())
1321 ret = false;
1322 } else {
1323#endif
1324 if (!(*iter)->Wipe())
1325 ret = false;
1326#ifdef TW_OEM_BUILD
1327 }
1328#endif
Dees_Troy094207a2012-09-26 12:00:39 -04001329 } else if ((*iter)->Has_Android_Secure) {
1330 if (!(*iter)->Wipe_AndSec())
1331 ret = false;
Dees_Troy63c8df72012-09-10 14:02:05 -04001332 }
1333 }
Ethan Yonker9fa76ba2016-06-30 14:05:43 -05001334 TWFunc::check_and_run_script("/sbin/factoryreset.sh", "Factory Reset Script");
Dees_Troy63c8df72012-09-10 14:02:05 -04001335 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04001336}
1337
Dees_Troy38bd7602012-09-14 13:33:53 -04001338int TWPartitionManager::Wipe_Dalvik_Cache(void) {
1339 struct stat st;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001340 vector <string> dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04001341
1342 if (!Mount_By_Path("/data", true))
1343 return false;
1344
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001345 dir.push_back("/data/dalvik-cache");
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001346
1347 std::string cacheDir = TWFunc::get_cache_dir();
1348 if (cacheDir == NON_AB_CACHE_DIR) {
1349 if (!PartitionManager.Mount_By_Path(NON_AB_CACHE_DIR, false)) {
1350 LOGINFO("Unable to mount %s for wiping cache.\n", NON_AB_CACHE_DIR);
1351 }
1352 dir.push_back(cacheDir + "dalvik-cache");
1353 dir.push_back(cacheDir + "/dc");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001354 }
Ethan Yonkerff2b7882016-12-10 09:04:41 -06001355
Dees_Troy38bd7602012-09-14 13:33:53 -04001356 TWPartition* sdext = Find_Partition_By_Path("/sd-ext");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001357 if (sdext && sdext->Is_Present && sdext->Mount(false))
1358 {
1359 if (stat("/sd-ext/dalvik-cache", &st) == 0)
1360 {
Ethan Yonkerff2b7882016-12-10 09:04:41 -06001361 dir.push_back("/sd-ext/dalvik-cache");
1362 }
1363 }
1364
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001365 if (cacheDir == NON_AB_CACHE_DIR) {
1366 gui_msg("wiping_cache_dalvik=Wiping Dalvik Cache Directories...");
1367 } else {
1368 gui_msg("wiping_dalvik=Wiping Dalvik Directory...");
1369 }
Ethan Yonkerff2b7882016-12-10 09:04:41 -06001370 for (unsigned i = 0; i < dir.size(); ++i) {
1371 if (stat(dir.at(i).c_str(), &st) == 0) {
1372 TWFunc::removeDir(dir.at(i), false);
1373 gui_msg(Msg("cleaned=Cleaned: {1}...")(dir.at(i)));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001374 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001375 }
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001376
1377 if (cacheDir == NON_AB_CACHE_DIR) {
1378 gui_msg("cache_dalvik_done=-- Dalvik Cache Directories Wipe Complete!");
1379 } else {
1380 gui_msg("dalvik_done=-- Dalvik Directory Wipe Complete!");
1381 }
1382
Dees_Troy38bd7602012-09-14 13:33:53 -04001383 return true;
1384}
1385
1386int TWPartitionManager::Wipe_Rotate_Data(void) {
1387 if (!Mount_By_Path("/data", true))
1388 return false;
1389
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001390 unlink("/data/misc/akmd*");
1391 unlink("/data/misc/rild*");
Dees_Troy2673cec2013-04-02 20:22:16 +00001392 gui_print("Rotation data wiped.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001393 return true;
1394}
1395
1396int TWPartitionManager::Wipe_Battery_Stats(void) {
1397 struct stat st;
1398
1399 if (!Mount_By_Path("/data", true))
1400 return false;
1401
1402 if (0 != stat("/data/system/batterystats.bin", &st)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001403 gui_print("No Battery Stats Found. No Need To Wipe.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001404 } else {
1405 remove("/data/system/batterystats.bin");
Dees_Troy2673cec2013-04-02 20:22:16 +00001406 gui_print("Cleared battery stats.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001407 }
1408 return true;
1409}
1410
Dees_Troy2ff5a8d2012-09-26 14:53:02 -04001411int TWPartitionManager::Wipe_Android_Secure(void) {
1412 std::vector<TWPartition*>::iterator iter;
1413 int ret = false;
1414 bool found = false;
1415
1416 // Iterate through all partitions
1417 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1418 if ((*iter)->Has_Android_Secure) {
1419 ret = (*iter)->Wipe_AndSec();
1420 found = true;
1421 }
1422 }
1423 if (found) {
1424 return ret;
1425 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001426 gui_err("no_andsec=No android secure partitions found.");
Dees_Troy2ff5a8d2012-09-26 14:53:02 -04001427 }
1428 return false;
1429}
1430
Dees_Troy38bd7602012-09-14 13:33:53 -04001431int TWPartitionManager::Format_Data(void) {
1432 TWPartition* dat = Find_Partition_By_Path("/data");
1433
1434 if (dat != NULL) {
1435 if (!dat->UnMount(true))
1436 return false;
1437
1438 return dat->Wipe_Encryption();
1439 } else {
Matt Mower3c366972015-12-25 19:28:31 -06001440 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")("/data"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001441 return false;
1442 }
1443 return false;
1444}
1445
1446int TWPartitionManager::Wipe_Media_From_Data(void) {
1447 TWPartition* dat = Find_Partition_By_Path("/data");
1448
1449 if (dat != NULL) {
1450 if (!dat->Has_Data_Media) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001451 LOGERR("This device does not have /data/media\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001452 return false;
1453 }
1454 if (!dat->Mount(true))
1455 return false;
1456
Ethan Yonker74db1572015-10-28 12:44:49 -05001457 gui_msg("wiping_datamedia=Wiping internal storage -- /data/media...");
Ethan Yonker726a0202014-12-16 20:01:38 -06001458 Remove_MTP_Storage(dat->MTP_Storage_ID);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001459 TWFunc::removeDir("/data/media", false);
xiaolu9416f4f2015-06-04 08:22:23 +08001460 dat->Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001461 Add_MTP_Storage(dat->MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001462 return true;
1463 } else {
Matt Mower3c366972015-12-25 19:28:31 -06001464 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")("/data"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001465 return false;
1466 }
1467 return false;
1468}
1469
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001470int TWPartitionManager::Repair_By_Path(string Path, bool Display_Error) {
1471 std::vector<TWPartition*>::iterator iter;
1472 int ret = false;
1473 bool found = false;
1474 string Local_Path = TWFunc::Get_Root_Path(Path);
1475
1476 if (Local_Path == "/tmp" || Local_Path == "/")
1477 return true;
1478
1479 // Iterate through all partitions
1480 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1481 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
1482 ret = (*iter)->Repair();
1483 found = true;
1484 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1485 (*iter)->Repair();
1486 }
1487 }
1488 if (found) {
1489 return ret;
1490 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001491 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Local_Path));
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001492 } else {
1493 LOGINFO("Repair: Unable to find partition for path '%s'\n", Local_Path.c_str());
1494 }
1495 return false;
1496}
1497
Ethan Yonkera2719152015-05-28 09:44:41 -05001498int TWPartitionManager::Resize_By_Path(string Path, bool Display_Error) {
1499 std::vector<TWPartition*>::iterator iter;
1500 int ret = false;
1501 bool found = false;
1502 string Local_Path = TWFunc::Get_Root_Path(Path);
1503
1504 if (Local_Path == "/tmp" || Local_Path == "/")
1505 return true;
1506
1507 // Iterate through all partitions
1508 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1509 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
1510 ret = (*iter)->Resize();
1511 found = true;
1512 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1513 (*iter)->Resize();
1514 }
1515 }
1516 if (found) {
1517 return ret;
1518 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001519 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Local_Path));
Ethan Yonkera2719152015-05-28 09:44:41 -05001520 } else {
1521 LOGINFO("Resize: Unable to find partition for path '%s'\n", Local_Path.c_str());
1522 }
1523 return false;
1524}
1525
Dees_Troy51a0e822012-09-05 15:24:24 -04001526void TWPartitionManager::Update_System_Details(void) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001527 std::vector<TWPartition*>::iterator iter;
Dees_Troy51127312012-09-08 13:08:49 -04001528 int data_size = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -04001529
Ethan Yonker74db1572015-10-28 12:44:49 -05001530 gui_msg("update_part_details=Updating partition details...");
Dees_Troy5bf43922012-09-07 16:07:55 -04001531 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Ethan Yonker1b190162016-12-05 15:25:19 -06001532 (*iter)->Update_Size(true);
Dees_Troy51127312012-09-08 13:08:49 -04001533 if ((*iter)->Can_Be_Mounted) {
Captain Throwback9d6feb52018-07-27 10:05:24 -04001534 if ((*iter)->Mount_Point == Get_Android_Root_Path()) {
Dees_Troy51127312012-09-08 13:08:49 -04001535 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1536 DataManager::SetValue(TW_BACKUP_SYSTEM_SIZE, backup_display_size);
1537 } else if ((*iter)->Mount_Point == "/data" || (*iter)->Mount_Point == "/datadata") {
1538 data_size += (int)((*iter)->Backup_Size / 1048576LLU);
1539 } else if ((*iter)->Mount_Point == "/cache") {
1540 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1541 DataManager::SetValue(TW_BACKUP_CACHE_SIZE, backup_display_size);
1542 } else if ((*iter)->Mount_Point == "/sd-ext") {
1543 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1544 DataManager::SetValue(TW_BACKUP_SDEXT_SIZE, backup_display_size);
1545 if ((*iter)->Backup_Size == 0) {
1546 DataManager::SetValue(TW_HAS_SDEXT_PARTITION, 0);
1547 DataManager::SetValue(TW_BACKUP_SDEXT_VAR, 0);
1548 } else
1549 DataManager::SetValue(TW_HAS_SDEXT_PARTITION, 1);
Dees_Troye58d5262012-09-21 12:27:57 -04001550 } else if ((*iter)->Has_Android_Secure) {
Dees_Troy8170a922012-09-18 15:40:25 -04001551 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
Dees_Troye58d5262012-09-21 12:27:57 -04001552 DataManager::SetValue(TW_BACKUP_ANDSEC_SIZE, backup_display_size);
Dees_Troy8170a922012-09-18 15:40:25 -04001553 if ((*iter)->Backup_Size == 0) {
1554 DataManager::SetValue(TW_HAS_ANDROID_SECURE, 0);
1555 DataManager::SetValue(TW_BACKUP_ANDSEC_VAR, 0);
1556 } else
1557 DataManager::SetValue(TW_HAS_ANDROID_SECURE, 1);
Dees_Troy2c50e182012-09-26 20:05:28 -04001558 } else if ((*iter)->Mount_Point == "/boot") {
1559 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1560 DataManager::SetValue(TW_BACKUP_BOOT_SIZE, backup_display_size);
1561 if ((*iter)->Backup_Size == 0) {
1562 DataManager::SetValue("tw_has_boot_partition", 0);
1563 DataManager::SetValue(TW_BACKUP_BOOT_VAR, 0);
1564 } else
1565 DataManager::SetValue("tw_has_boot_partition", 1);
Dees_Troy51127312012-09-08 13:08:49 -04001566 }
Dees_Troyaa9cc402012-10-13 12:14:05 -04001567 } else {
1568 // Handle unmountable partitions in case we reset defaults
1569 if ((*iter)->Mount_Point == "/boot") {
1570 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1571 DataManager::SetValue(TW_BACKUP_BOOT_SIZE, backup_display_size);
1572 if ((*iter)->Backup_Size == 0) {
1573 DataManager::SetValue(TW_HAS_BOOT_PARTITION, 0);
1574 DataManager::SetValue(TW_BACKUP_BOOT_VAR, 0);
1575 } else
1576 DataManager::SetValue(TW_HAS_BOOT_PARTITION, 1);
1577 } else if ((*iter)->Mount_Point == "/recovery") {
1578 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1579 DataManager::SetValue(TW_BACKUP_RECOVERY_SIZE, backup_display_size);
1580 if ((*iter)->Backup_Size == 0) {
1581 DataManager::SetValue(TW_HAS_RECOVERY_PARTITION, 0);
1582 DataManager::SetValue(TW_BACKUP_RECOVERY_VAR, 0);
1583 } else
1584 DataManager::SetValue(TW_HAS_RECOVERY_PARTITION, 1);
Gary Peck82599a82012-11-21 16:23:12 -08001585 } else if ((*iter)->Mount_Point == "/data") {
1586 data_size += (int)((*iter)->Backup_Size / 1048576LLU);
Dees_Troyaa9cc402012-10-13 12:14:05 -04001587 }
Dees_Troy51127312012-09-08 13:08:49 -04001588 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001589 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001590 gui_msg("update_part_details_done=...done");
Dees_Troy51127312012-09-08 13:08:49 -04001591 DataManager::SetValue(TW_BACKUP_DATA_SIZE, data_size);
1592 string current_storage_path = DataManager::GetCurrentStoragePath();
1593 TWPartition* FreeStorage = Find_Partition_By_Path(current_storage_path);
Dees_Troy8170a922012-09-18 15:40:25 -04001594 if (FreeStorage != NULL) {
1595 // Attempt to mount storage
1596 if (!FreeStorage->Mount(false)) {
Matt Mower2d50cad2015-12-03 22:26:55 -06001597 gui_msg(Msg(msg::kError, "unable_to_mount_storage=Unable to mount storage"));
1598 DataManager::SetValue(TW_STORAGE_FREE_SIZE, 0);
Dees_Troy8170a922012-09-18 15:40:25 -04001599 } else {
1600 DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)(FreeStorage->Free / 1048576LLU));
1601 }
1602 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001603 LOGINFO("Unable to find storage partition '%s'.\n", current_storage_path.c_str());
Dees_Troy8170a922012-09-18 15:40:25 -04001604 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001605 if (!Write_Fstab())
Dees_Troy2673cec2013-04-02 20:22:16 +00001606 LOGERR("Error creating fstab\n");
Dees_Troy51a0e822012-09-05 15:24:24 -04001607 return;
1608}
1609
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001610void TWPartitionManager::Post_Decrypt(const string& Block_Device) {
1611 TWPartition* dat = Find_Partition_By_Path("/data");
1612 if (dat != NULL) {
1613 DataManager::SetValue(TW_IS_DECRYPTED, 1);
1614 dat->Is_Decrypted = true;
1615 if (!Block_Device.empty()) {
1616 dat->Decrypted_Block_Device = Block_Device;
1617 gui_msg(Msg("decrypt_success_dev=Data successfully decrypted, new block device: '{1}'")(Block_Device));
1618 } else {
1619 gui_msg("decrypt_success_nodev=Data successfully decrypted");
1620 }
1621 dat->Setup_File_System(false);
1622 dat->Current_File_System = dat->Fstab_File_System; // Needed if we're ignoring blkid because encrypted devices start out as emmc
1623
1624 // Sleep for a bit so that the device will be ready
1625 sleep(1);
1626 if (dat->Has_Data_Media && dat->Mount(false) && TWFunc::Path_Exists("/data/media/0")) {
1627 dat->Storage_Path = "/data/media/0";
1628 dat->Symlink_Path