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 = dat->Storage_Path;
1629 DataManager::SetValue("tw_storage_path", "/data/media/0");
1630 DataManager::SetValue("tw_settings_path", "/data/media/0");
1631 dat->UnMount(false);
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001632 }
1633 Update_System_Details();
nkk71ffb02bd2017-06-04 23:12:16 +03001634 Output_Partition(dat);
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001635 UnMount_Main_Partitions();
1636 } else
1637 LOGERR("Unable to locate data partition.\n");
1638}
1639
Dees_Troy51a0e822012-09-05 15:24:24 -04001640int TWPartitionManager::Decrypt_Device(string Password) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001641#ifdef TW_INCLUDE_CRYPTO
Ethan Yonkerddb63e22017-01-19 14:01:57 -06001642 char crypto_state[PROPERTY_VALUE_MAX], crypto_blkdev[PROPERTY_VALUE_MAX];
Ethan Yonker253368a2014-11-25 15:00:52 -06001643 std::vector<TWPartition*>::iterator iter;
Dees_Troy5bf43922012-09-07 16:07:55 -04001644
Ethan Yonker253368a2014-11-25 15:00:52 -06001645 // Mount any partitions that need to be mounted for decrypt
1646 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1647 if ((*iter)->Mount_To_Decrypt) {
1648 (*iter)->Mount(true);
1649 }
a39552696ff55ce2013-01-08 16:14:56 +00001650 }
oshmouna82a7542018-04-10 17:45:55 +02001651 property_set("twrp.mount_to_decrypt", "1");
a39552696ff55ce2013-01-08 16:14:56 +00001652
Ethan Yonkera1de1492015-11-04 11:58:27 -06001653 property_get("ro.crypto.state", crypto_state, "error");
1654 if (strcmp(crypto_state, "error") == 0) {
1655 property_set("ro.crypto.state", "encrypted");
1656 // Sleep for a bit so that services can start if needed
1657 sleep(1);
1658 }
1659
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001660 if (DataManager::GetIntValue(TW_IS_FBE)) {
1661#ifdef TW_INCLUDE_FBE
1662 if (!Mount_By_Path("/data", true)) // /data has to be mounted for FBE
1663 return -1;
1664 int retry_count = 10;
1665 while (!TWFunc::Path_Exists("/data/system/users/gatekeeper.password.key") && --retry_count)
1666 usleep(2000); // A small sleep is needed after mounting /data to ensure reliable decrypt... maybe because of DE?
1667 int user_id = DataManager::GetIntValue("tw_decrypt_user_id");
1668 LOGINFO("Decrypting FBE for user %i\n", user_id);
1669 if (Decrypt_User(user_id, Password)) {
1670 Post_Decrypt("");
1671 return 0;
1672 }
1673#else
1674 LOGERR("FBE support is not present\n");
1675#endif
1676 return -1;
1677 }
1678
Ethan Yonkerddb63e22017-01-19 14:01:57 -06001679 int pwret = -1;
1680 pid_t pid = fork();
1681 if (pid < 0) {
1682 LOGERR("fork failed\n");
1683 return -1;
1684 } else if (pid == 0) {
1685 // Child process
1686 char cPassword[255];
1687 strcpy(cPassword, Password.c_str());
1688 int ret = cryptfs_check_passwd(cPassword);
1689 exit(ret);
1690 } else {
1691 // Parent
1692 int status;
1693 if (TWFunc::Wait_For_Child_Timeout(pid, &status, "Decrypt", 30))
1694 pwret = -1;
1695 else
1696 pwret = WEXITSTATUS(status) ? -1 : 0;
1697 }
a39552696ff55ce2013-01-08 16:14:56 +00001698
nkk7171c6c502017-01-05 23:55:05 +02001699#ifdef TW_CRYPTO_USE_SYSTEM_VOLD
1700 if (pwret != 0) {
1701 pwret = vold_decrypt(Password);
nkk717d1222a2017-11-06 17:27:21 +02001702 switch (pwret) {
1703 case VD_SUCCESS:
1704 break;
1705 case VD_ERR_MISSING_VDC:
1706 gui_msg(Msg(msg::kError, "decrypt_data_vold_os_missing=Missing files needed for vold decrypt: {1}")("/system/bin/vdc"));
1707 break;
1708 case VD_ERR_MISSING_VOLD:
1709 gui_msg(Msg(msg::kError, "decrypt_data_vold_os_missing=Missing files needed for vold decrypt: {1}")("/system/bin/vold"));
1710 break;
1711 }
nkk7171c6c502017-01-05 23:55:05 +02001712 }
1713#endif // TW_CRYPTO_USE_SYSTEM_VOLD
1714
Ethan Yonker253368a2014-11-25 15:00:52 -06001715 // Unmount any partitions that were needed for decrypt
1716 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1717 if ((*iter)->Mount_To_Decrypt) {
1718 (*iter)->UnMount(false);
1719 }
1720 }
oshmouna82a7542018-04-10 17:45:55 +02001721 property_set("twrp.mount_to_decrypt", "0");
Ethan Yonker253368a2014-11-25 15:00:52 -06001722
a39552696ff55ce2013-01-08 16:14:56 +00001723 if (pwret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001724 gui_err("fail_decrypt=Failed to decrypt data.");
Dees_Troy5bf43922012-09-07 16:07:55 -04001725 return -1;
1726 }
a39552696ff55ce2013-01-08 16:14:56 +00001727
Dees_Troy5bf43922012-09-07 16:07:55 -04001728 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
1729 if (strcmp(crypto_blkdev, "error") == 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001730 LOGERR("Error retrieving decrypted data block device.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001731 } else {
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001732 Post_Decrypt(crypto_blkdev);
Dees_Troy5bf43922012-09-07 16:07:55 -04001733 }
1734 return 0;
1735#else
Ethan Yonker74db1572015-10-28 12:44:49 -05001736 gui_err("no_crypto_support=No crypto support was compiled into this build.");
Dees_Troy5bf43922012-09-07 16:07:55 -04001737 return -1;
1738#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04001739 return 1;
Dees_Troy51127312012-09-08 13:08:49 -04001740}
1741
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001742int TWPartitionManager::Fix_Contexts(void) {
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001743 std::vector<TWPartition*>::iterator iter;
1744 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1745 if ((*iter)->Has_Data_Media) {
1746 if ((*iter)->Mount(true)) {
1747 if (fixContexts::fixDataMediaContexts((*iter)->Mount_Point) != 0)
1748 return -1;
1749 }
1750 }
1751 }
Dees_Troy1a650e62012-10-19 20:54:32 -04001752 UnMount_Main_Partitions();
Ethan Yonker74db1572015-10-28 12:44:49 -05001753 gui_msg("done=Done.");
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001754 return 0;
bigbiff bigbiffa0f8a592012-10-09 21:01:03 -04001755}
1756
Ethan Yonker66a19492015-12-10 10:19:45 -06001757TWPartition* TWPartitionManager::Find_Next_Storage(string Path, bool Exclude_Data_Media) {
Ethan Yonker47360be2014-04-01 10:34:34 -05001758 std::vector<TWPartition*>::iterator iter = Partitions.begin();
1759
1760 if (!Path.empty()) {
1761 string Search_Path = TWFunc::Get_Root_Path(Path);
1762 for (; iter != Partitions.end(); iter++) {
Matt Mower9a561dd2016-02-22 21:25:51 -06001763 if ((*iter)->Mount_Point == Search_Path) {
Ethan Yonker47360be2014-04-01 10:34:34 -05001764 iter++;
1765 break;
1766 }
1767 }
1768 }
1769
1770 for (; iter != Partitions.end(); iter++) {
Ethan Yonker66a19492015-12-10 10:19:45 -06001771 if (Exclude_Data_Media && (*iter)->Has_Data_Media) {
1772 // do nothing, do not return this type of partition
1773 } else if ((*iter)->Is_Storage && (*iter)->Is_Present) {
Ethan Yonker47360be2014-04-01 10:34:34 -05001774 return (*iter);
1775 }
1776 }
1777
1778 return NULL;
1779}
1780
Dees_Troyd21618c2012-10-14 18:48:49 -04001781int TWPartitionManager::Open_Lun_File(string Partition_Path, string Lun_File) {
Dees_Troyd21618c2012-10-14 18:48:49 -04001782 TWPartition* Part = Find_Partition_By_Path(Partition_Path);
1783
1784 if (Part == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001785 LOGINFO("Unable to locate '%s' for USB storage mode.", Partition_Path.c_str());
1786 gui_msg(Msg(msg::kError, "unable_find_part_path=Unable to find partition for path '{1}'")(Partition_Path));
Dees_Troyd21618c2012-10-14 18:48:49 -04001787 return false;
1788 }
Ethan Yonker47360be2014-04-01 10:34:34 -05001789 LOGINFO("USB mount '%s', '%s' > '%s'\n", Partition_Path.c_str(), Part->Actual_Block_Device.c_str(), Lun_File.c_str());
1790 if (!Part->UnMount(true) || !Part->Is_Present)
Dees_Troyd21618c2012-10-14 18:48:49 -04001791 return false;
1792
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001793 if (TWFunc::write_to_file(Lun_File, Part->Actual_Block_Device)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001794 LOGERR("Unable to write to ums lunfile '%s': (%s)\n", Lun_File.c_str(), strerror(errno));
Dees_Troyd21618c2012-10-14 18:48:49 -04001795 return false;
1796 }
Dees_Troyd21618c2012-10-14 18:48:49 -04001797 return true;
1798}
1799
Dees_Troy8170a922012-09-18 15:40:25 -04001800int TWPartitionManager::usb_storage_enable(void) {
Dees_Troy8170a922012-09-18 15:40:25 -04001801 char lun_file[255];
Dees_Troyd21618c2012-10-14 18:48:49 -04001802 bool has_multiple_lun = false;
Dees_Troy8170a922012-09-18 15:40:25 -04001803
Ethan Yonker47360be2014-04-01 10:34:34 -05001804 string Lun_File_str = CUSTOM_LUN_FILE;
1805 size_t found = Lun_File_str.find("%");
1806 if (found != string::npos) {
1807 sprintf(lun_file, CUSTOM_LUN_FILE, 1);
1808 if (TWFunc::Path_Exists(lun_file))
1809 has_multiple_lun = true;
1810 }
Ethan Yonker726a0202014-12-16 20:01:38 -06001811 mtp_was_enabled = TWFunc::Toggle_MTP(false); // Must disable MTP for USB Storage
Ethan Yonker47360be2014-04-01 10:34:34 -05001812 if (!has_multiple_lun) {
1813 LOGINFO("Device doesn't have multiple lun files, mount current storage\n");
1814 sprintf(lun_file, CUSTOM_LUN_FILE, 0);
1815 if (TWFunc::Get_Root_Path(DataManager::GetCurrentStoragePath()) == "/data") {
Ethan Yonker66a19492015-12-10 10:19:45 -06001816 TWPartition* Mount = Find_Next_Storage("", true);
Ethan Yonker47360be2014-04-01 10:34:34 -05001817 if (Mount) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001818 if (!Open_Lun_File(Mount->Mount_Point, lun_file)) {
1819 goto error_handle;
1820 }
Ethan Yonker47360be2014-04-01 10:34:34 -05001821 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001822 gui_err("unable_locate_storage=Unable to locate storage device.");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001823 goto error_handle;
Ethan Yonker47360be2014-04-01 10:34:34 -05001824 }
1825 } else if (!Open_Lun_File(DataManager::GetCurrentStoragePath(), lun_file)) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001826 goto error_handle;
Dees_Troy8170a922012-09-18 15:40:25 -04001827 }
Dees_Troy8170a922012-09-18 15:40:25 -04001828 } else {
Ethan Yonker47360be2014-04-01 10:34:34 -05001829 LOGINFO("Device has multiple lun files\n");
1830 TWPartition* Mount1;
1831 TWPartition* Mount2;
Dees_Troy8170a922012-09-18 15:40:25 -04001832 sprintf(lun_file, CUSTOM_LUN_FILE, 0);
Ethan Yonker66a19492015-12-10 10:19:45 -06001833 Mount1 = Find_Next_Storage("", true);
Ethan Yonker47360be2014-04-01 10:34:34 -05001834 if (Mount1) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001835 if (!Open_Lun_File(Mount1->Mount_Point, lun_file)) {
1836 goto error_handle;
1837 }
Matt Moweree717062014-04-26 01:46:46 -05001838 sprintf(lun_file, CUSTOM_LUN_FILE, 1);
Ethan Yonker66a19492015-12-10 10:19:45 -06001839 Mount2 = Find_Next_Storage(Mount1->Mount_Point, true);
Matt Mower1fdcdb72016-01-25 20:53:47 -06001840 if (Mount2 && Mount2->Mount_Point != Mount1->Mount_Point) {
Matt Moweree717062014-04-26 01:46:46 -05001841 Open_Lun_File(Mount2->Mount_Point, lun_file);
Ethan Yonker47360be2014-04-01 10:34:34 -05001842 }
1843 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001844 gui_err("unable_locate_storage=Unable to locate storage device.");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001845 goto error_handle;
Ethan Yonker47360be2014-04-01 10:34:34 -05001846 }
Dees_Troy8170a922012-09-18 15:40:25 -04001847 }
Matt Mowerb6ef4782014-11-06 02:24:36 -06001848 property_set("sys.storage.ums_enabled", "1");
HandyMenny37d42992014-10-26 22:15:59 +01001849 property_set("sys.usb.config", "mass_storage,adb");
Dees_Troy8170a922012-09-18 15:40:25 -04001850 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001851error_handle:
1852 if (mtp_was_enabled)
1853 if (!Enable_MTP())
1854 Disable_MTP();
1855 return false;
Dees_Troy8170a922012-09-18 15:40:25 -04001856}
1857
1858int TWPartitionManager::usb_storage_disable(void) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001859 int index, ret;
1860 char lun_file[255], ch[2] = {0, 0};
1861 string str = ch;
Dees_Troy8170a922012-09-18 15:40:25 -04001862
1863 for (index=0; index<2; index++) {
1864 sprintf(lun_file, CUSTOM_LUN_FILE, index);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001865 ret = TWFunc::write_to_file(lun_file, str);
Dees_Troy2673cec2013-04-02 20:22:16 +00001866 if (ret < 0) {
1867 break;
Dees_Troy8170a922012-09-18 15:40:25 -04001868 }
Dees_Troy8170a922012-09-18 15:40:25 -04001869 }
Dees_Troye58d5262012-09-21 12:27:57 -04001870 Mount_All_Storage();
1871 Update_System_Details();
Dees_Troycfd73ef2012-10-12 16:52:00 -04001872 UnMount_Main_Partitions();
Matt Mowerd9cb9062013-12-14 20:34:45 -06001873 property_set("sys.storage.ums_enabled", "0");
HandyMenny37d42992014-10-26 22:15:59 +01001874 property_set("sys.usb.config", "adb");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001875 if (mtp_was_enabled)
1876 if (!Enable_MTP())
1877 Disable_MTP();
Dees_Troy2673cec2013-04-02 20:22:16 +00001878 if (ret < 0 && index == 0) {
1879 LOGERR("Unable to write to ums lunfile '%s'.", lun_file);
1880 return false;
1881 } else {
1882 return true;
1883 }
Dees_Troy8170a922012-09-18 15:40:25 -04001884 return true;
Dees_Troy812660f2012-09-20 09:55:17 -04001885}
1886
1887void TWPartitionManager::Mount_All_Storage(void) {
1888 std::vector<TWPartition*>::iterator iter;
1889
1890 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1891 if ((*iter)->Is_Storage)
1892 (*iter)->Mount(false);
1893 }
Dees_Troy2c50e182012-09-26 20:05:28 -04001894}
Dees_Troy9350b8d2012-09-27 12:38:38 -04001895
Dees_Troyd0384ef2012-10-12 12:15:42 -04001896void TWPartitionManager::UnMount_Main_Partitions(void) {
1897 // Unmounts system and data if data is not data/media
1898 // Also unmounts boot if boot is mountable
Dees_Troy2673cec2013-04-02 20:22:16 +00001899 LOGINFO("Unmounting main partitions...\n");
Dees_Troyd0384ef2012-10-12 12:15:42 -04001900
1901 TWPartition* Boot_Partition = Find_Partition_By_Path("/boot");
1902
Captain Throwback9d6feb52018-07-27 10:05:24 -04001903 UnMount_By_Path(Get_Android_Root_Path(), true);
Ethan Yonker6277c792014-09-15 14:54:30 -05001904 if (!datamedia)
1905 UnMount_By_Path("/data", true);
1906
Dees_Troyd0384ef2012-10-12 12:15:42 -04001907 if (Boot_Partition != NULL && Boot_Partition->Can_Be_Mounted)
1908 Boot_Partition->UnMount(true);
1909}
1910
Dees_Troy9350b8d2012-09-27 12:38:38 -04001911int TWPartitionManager::Partition_SDCard(void) {
Matt Mower23d8aae2017-01-06 14:30:33 -06001912 char temp[255];
Ethan Yonker483e9f42016-01-11 22:21:18 -06001913 string Storage_Path, Command, Device, fat_str, ext_str, start_loc, end_loc, ext_format, sd_path, tmpdevice;
Dees_Troy9350b8d2012-09-27 12:38:38 -04001914 int ext, swap, total_size = 0, fat_size;
Dees_Troy9350b8d2012-09-27 12:38:38 -04001915
Ethan Yonker74db1572015-10-28 12:44:49 -05001916 gui_msg("start_partition_sd=Partitioning SD Card...");
Ethan Yonker483e9f42016-01-11 22:21:18 -06001917
1918 // Locate and validate device to partition
1919 TWPartition* SDCard = Find_Partition_By_Path(DataManager::GetCurrentStoragePath());
1920
Ethan Yonker66a19492015-12-10 10:19:45 -06001921 if (SDCard->Is_Adopted_Storage)
1922 SDCard->Revert_Adopted();
1923
Ethan Yonker1eff6cd2014-09-15 13:30:42 -05001924 if (SDCard == NULL || !SDCard->Removable || SDCard->Has_Data_Media) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001925 gui_err("partition_sd_locate=Unable to locate device to partition.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04001926 return false;
1927 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001928
1929 // Unmount everything
Dees_Troy9350b8d2012-09-27 12:38:38 -04001930 if (!SDCard->UnMount(true))
1931 return false;
1932 TWPartition* SDext = Find_Partition_By_Path("/sd-ext");
1933 if (SDext != NULL) {
1934 if (!SDext->UnMount(true))
1935 return false;
1936 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001937 char* swappath = getenv("SWAPPATH");
1938 if (swappath != NULL) {
1939 LOGINFO("Unmounting swap at '%s'\n", swappath);
1940 umount(swappath);
1941 }
Vojtech Bocek05534202013-09-11 08:11:56 +02001942
Ethan Yonker483e9f42016-01-11 22:21:18 -06001943 // Determine block device
1944 if (SDCard->Alternate_Block_Device.empty()) {
1945 SDCard->Find_Actual_Block_Device();
1946 Device = SDCard->Actual_Block_Device;
1947 // Just use the root block device
1948 Device.resize(strlen("/dev/block/mmcblkX"));
1949 } else {
1950 Device = SDCard->Alternate_Block_Device;
1951 }
Dees_Troy9350b8d2012-09-27 12:38:38 -04001952
1953 // Find the size of the block device:
Ethan Yonker483e9f42016-01-11 22:21:18 -06001954 total_size = (int)(TWFunc::IOCTL_Get_Block_Size(Device.c_str()) / (1048576));
Dees_Troy9350b8d2012-09-27 12:38:38 -04001955
1956 DataManager::GetValue("tw_sdext_size", ext);
1957 DataManager::GetValue("tw_swap_size", swap);
1958 DataManager::GetValue("tw_sdpart_file_system", ext_format);
1959 fat_size = total_size - ext - swap;
Ethan Yonker483e9f42016-01-11 22:21:18 -06001960 LOGINFO("sd card mount point %s block device is '%s', sdcard size is: %iMB, fat size: %iMB, ext size: %iMB, ext system: '%s', swap size: %iMB\n", DataManager::GetCurrentStoragePath().c_str(), Device.c_str(), total_size, fat_size, ext, ext_format.c_str(), swap);
1961
1962 // Determine partition sizes
1963 if (swap == 0 && ext == 0) {
1964 fat_str = "-0";
1965 } else {
1966 memset(temp, 0, sizeof(temp));
1967 sprintf(temp, "%i", fat_size);
1968 fat_str = temp;
1969 fat_str += "MB";
1970 }
1971 if (swap == 0) {
1972 ext_str = "-0";
1973 } else {
1974 memset(temp, 0, sizeof(temp));
1975 sprintf(temp, "%i", ext);
1976 ext_str = "+";
1977 ext_str += temp;
1978 ext_str += "MB";
1979 }
1980
Dees_Troy9350b8d2012-09-27 12:38:38 -04001981 if (ext + swap > total_size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001982 gui_err("ext_swap_size=EXT + Swap size is larger than sdcard size.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04001983 return false;
1984 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001985
Ethan Yonker74db1572015-10-28 12:44:49 -05001986 gui_msg("remove_part_table=Removing partition table...");
Ethan Yonker483e9f42016-01-11 22:21:18 -06001987 Command = "sgdisk --zap-all " + Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001988 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001989 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001990 gui_err("unable_rm_part=Unable to remove partition table.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04001991 Update_System_Details();
1992 return false;
1993 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001994 gui_msg(Msg("create_part=Creating {1} partition...")("FAT32"));
Captain Throwback9643a802016-05-27 11:44:51 -04001995 Command = "sgdisk --new=0:0:" + fat_str + " --change-name=0:\"Microsoft basic data\" --typecode=0:EBD0A0A2-B9E5-4433-87C0-68B6B72699C7 " + Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001996 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001997 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001998 gui_msg(Msg(msg::kError, "unable_to_create_part=Unable to create {1} partition.")("FAT32"));
Dees_Troy9350b8d2012-09-27 12:38:38 -04001999 return false;
2000 }
2001 if (ext > 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002002 gui_msg(Msg("create_part=Creating {1} partition...")("EXT"));
Ethan Yonker483e9f42016-01-11 22:21:18 -06002003 Command = "sgdisk --new=0:0:" + ext_str + " --change-name=0:\"Linux filesystem\" " + Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00002004 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002005 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002006 gui_msg(Msg(msg::kError, "unable_to_create_part=Unable to create {1} partition.")("EXT"));
Dees_Troy9350b8d2012-09-27 12:38:38 -04002007 Update_System_Details();
2008 return false;
2009 }
2010 }
2011 if (swap > 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002012 gui_msg(Msg("create_part=Creating {1} partition...")("swap"));
Ethan Yonker483e9f42016-01-11 22:21:18 -06002013 Command = "sgdisk --new=0:0:-0 --change-name=0:\"Linux swap\" --typecode=0:0657FD6D-A4AB-43C4-84E5-0933C84B4F4F " + Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00002014 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02002015 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002016 gui_msg(Msg(msg::kError, "unable_to_create_part=Unable to create {1} partition.")("swap"));
Dees_Troy9350b8d2012-09-27 12:38:38 -04002017 Update_System_Details();
2018 return false;
2019 }
2020 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06002021
2022 // Convert GPT to MBR
2023 Command = "sgdisk --gpttombr " + Device;
2024 if (TWFunc::Exec_Cmd(Command) != 0)
2025 LOGINFO("Failed to covert partition GPT to MBR\n");
2026
2027 // Tell the kernel to rescan the partition table
2028 int fd = open(Device.c_str(), O_RDONLY);
2029 ioctl(fd, BLKRRPART, 0);
2030 close(fd);
2031
2032 string format_device = Device;
2033 if (Device.substr(0, 17) == "/dev/block/mmcblk")
2034 format_device += "p";
2035
2036 // Format new partitions to proper file system
2037 if (fat_size > 0) {
2038 Command = "mkfs.fat " + format_device + "1";
2039 TWFunc::Exec_Cmd(Command);
2040 }
Dees_Troy9350b8d2012-09-27 12:38:38 -04002041 if (ext > 0) {
2042 if (SDext == NULL) {
Ethan Yonker483e9f42016-01-11 22:21:18 -06002043 Command = "mke2fs -t " + ext_format + " -m 0 " + format_device + "2";
2044 gui_msg(Msg("format_sdext_as=Formatting sd-ext as {1}...")(ext_format));
2045 LOGINFO("Formatting sd-ext after partitioning, command: '%s'\n", Command.c_str());
2046 TWFunc::Exec_Cmd(Command);
2047 } else {
2048 SDext->Wipe(ext_format);
Dees_Troy9350b8d2012-09-27 12:38:38 -04002049 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06002050 }
2051 if (swap > 0) {
2052 Command = "mkswap " + format_device;
2053 if (ext > 0)
2054 Command += "3";
2055 else
2056 Command += "2";
Vojtech Bocek05534202013-09-11 08:11:56 +02002057 TWFunc::Exec_Cmd(Command);
Dees_Troy9350b8d2012-09-27 12:38:38 -04002058 }
2059
Ethan Yonker483e9f42016-01-11 22:21:18 -06002060 // recreate TWRP folder and rewrite settings - these will be gone after sdcard is partitioned
2061 if (SDCard->Mount(true)) {
2062 string TWRP_Folder = SDCard->Mount_Point + "/TWRP";
2063 mkdir(TWRP_Folder.c_str(), 0777);
2064 DataManager::Flush();
2065 }
2066
Dees_Troy9350b8d2012-09-27 12:38:38 -04002067 Update_System_Details();
Ethan Yonker74db1572015-10-28 12:44:49 -05002068 gui_msg("part_complete=Partitioning complete.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04002069 return true;
bigbiff bigbiffa0f8a592012-10-09 21:01:03 -04002070}
Dees_Troya13d74f2013-03-24 08:54:55 -05002071
2072void TWPartitionManager::Get_Partition_List(string ListType, std::vector<PartitionList> *Partition_List) {
2073 std::vector<TWPartition*>::iterator iter;
2074 if (ListType == "mount") {
2075 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002076 if ((*iter)->Can_Be_Mounted) {
Dees_Troya13d74f2013-03-24 08:54:55 -05002077 struct PartitionList part;
2078 part.Display_Name = (*iter)->Display_Name;
2079 part.Mount_Point = (*iter)->Mount_Point;
2080 part.selected = (*iter)->Is_Mounted();
2081 Partition_List->push_back(part);
2082 }
2083 }
2084 } else if (ListType == "storage") {
2085 char free_space[255];
2086 string Current_Storage = DataManager::GetCurrentStoragePath();
2087 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2088 if ((*iter)->Is_Storage) {
2089 struct PartitionList part;
2090 sprintf(free_space, "%llu", (*iter)->Free / 1024 / 1024);
2091 part.Display_Name = (*iter)->Storage_Name + " (";
2092 part.Display_Name += free_space;
2093 part.Display_Name += "MB)";
2094 part.Mount_Point = (*iter)->Storage_Path;
2095 if ((*iter)->Storage_Path == Current_Storage)
2096 part.selected = 1;
2097 else
2098 part.selected = 0;
2099 Partition_List->push_back(part);
2100 }
2101 }
2102 } else if (ListType == "backup") {
2103 char backup_size[255];
Dees_Troy9e0b71c2013-04-08 13:35:37 +00002104 unsigned long long Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -05002105 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy9e0b71c2013-04-08 13:35:37 +00002106 if ((*iter)->Can_Be_Backed_Up && !(*iter)->Is_SubPartition && (*iter)->Is_Present) {
Dees_Troya13d74f2013-03-24 08:54:55 -05002107 struct PartitionList part;
Dees_Troy9e0b71c2013-04-08 13:35:37 +00002108 Backup_Size = (*iter)->Backup_Size;
2109 if ((*iter)->Has_SubPartition) {
2110 std::vector<TWPartition*>::iterator subpart;
2111
2112 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
2113 if ((*subpart)->Is_SubPartition && (*subpart)->Can_Be_Backed_Up && (*subpart)->Is_Present && (*subpart)->SubPartition_Of == (*iter)->Mount_Point)
2114 Backup_Size += (*subpart)->Backup_Size;
2115 }
2116 }
2117 sprintf(backup_size, "%llu", Backup_Size / 1024 / 1024);
Dees_Troya13d74f2013-03-24 08:54:55 -05002118 part.Display_Name = (*iter)->Backup_Display_Name + " (";
2119 part.Display_Name += backup_size;
2120 part.Display_Name += "MB)";
2121 part.Mount_Point = (*iter)->Backup_Path;
2122 part.selected = 0;
2123 Partition_List->push_back(part);
2124 }
2125 }
2126 } else if (ListType == "restore") {
2127 string Restore_List, restore_path;
2128 TWPartition* restore_part = NULL;
2129
2130 DataManager::GetValue("tw_restore_list", Restore_List);
2131 if (!Restore_List.empty()) {
2132 size_t start_pos = 0, end_pos = Restore_List.find(";", start_pos);
2133 while (end_pos != string::npos && start_pos < Restore_List.size()) {
2134 restore_path = Restore_List.substr(start_pos, end_pos - start_pos);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002135 struct PartitionList part;
2136 if (restore_path.compare("ADB_Backup") == 0) {
2137 part.Display_Name = "ADB Backup";
2138 part.Mount_Point = "ADB Backup";
2139 part.selected = 1;
2140 Partition_List->push_back(part);
2141 break;
2142 }
Dees_Troy59df9262013-06-19 14:53:57 -05002143 if ((restore_part = Find_Partition_By_Path(restore_path)) != NULL) {
Dees Troy4159aed2014-02-28 17:24:43 +00002144 if ((restore_part->Backup_Name == "recovery" && !restore_part->Can_Be_Backed_Up) || restore_part->Is_SubPartition) {
Dees_Troya13d74f2013-03-24 08:54:55 -05002145 // Don't allow restore of recovery (causes problems on some devices)
Dees_Troy59df9262013-06-19 14:53:57 -05002146 // Don't add subpartitions to the list of items
Dees_Troya13d74f2013-03-24 08:54:55 -05002147 } else {
Dees_Troya13d74f2013-03-24 08:54:55 -05002148 part.Display_Name = restore_part->Backup_Display_Name;
2149 part.Mount_Point = restore_part->Backup_Path;
2150 part.selected = 1;
2151 Partition_List->push_back(part);
2152 }
2153 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002154 gui_msg(Msg(msg::kError, "restore_unable_locate=Unable to locate '{1}' partition for restoring.")(restore_path));
Dees_Troya13d74f2013-03-24 08:54:55 -05002155 }
2156 start_pos = end_pos + 1;
2157 end_pos = Restore_List.find(";", start_pos);
2158 }
2159 }
2160 } else if (ListType == "wipe") {
2161 struct PartitionList dalvik;
Ethan Yonker74db1572015-10-28 12:44:49 -05002162 dalvik.Display_Name = gui_parse_text("{@dalvik}");
Dees_Troya13d74f2013-03-24 08:54:55 -05002163 dalvik.Mount_Point = "DALVIK";
2164 dalvik.selected = 0;
2165 Partition_List->push_back(dalvik);
2166 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2167 if ((*iter)->Wipe_Available_in_GUI && !(*iter)->Is_SubPartition) {
2168 struct PartitionList part;
2169 part.Display_Name = (*iter)->Display_Name;
2170 part.Mount_Point = (*iter)->Mount_Point;
2171 part.selected = 0;
2172 Partition_List->push_back(part);
2173 }
2174 if ((*iter)->Has_Android_Secure) {
2175 struct PartitionList part;
2176 part.Display_Name = (*iter)->Backup_Display_Name;
2177 part.Mount_Point = (*iter)->Backup_Path;
2178 part.selected = 0;
2179 Partition_List->push_back(part);
2180 }
Dees_Troy74fb2e92013-04-15 14:35:47 +00002181 if ((*iter)->Has_Data_Media) {
2182 struct PartitionList datamedia;
2183 datamedia.Display_Name = (*iter)->Storage_Name;
2184 datamedia.Mount_Point = "INTERNAL";
2185 datamedia.selected = 0;
2186 Partition_List->push_back(datamedia);
2187 }
Dees_Troya13d74f2013-03-24 08:54:55 -05002188 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002189 } else if (ListType == "flashimg") {
2190 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2191 if ((*iter)->Can_Flash_Img && (*iter)->Is_Present) {
2192 struct PartitionList part;
2193 part.Display_Name = (*iter)->Backup_Display_Name;
2194 part.Mount_Point = (*iter)->Backup_Path;
2195 part.selected = 0;
2196 Partition_List->push_back(part);
2197 }
2198 }
Dees_Troya13d74f2013-03-24 08:54:55 -05002199 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00002200 LOGERR("Unknown list type '%s' requested for TWPartitionManager::Get_Partition_List\n", ListType.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -05002201 }
2202}
2203
2204int TWPartitionManager::Fstab_Processed(void) {
2205 return Partitions.size();
2206}
Dees_Troyd93bda52013-07-03 19:55:19 +00002207
2208void TWPartitionManager::Output_Storage_Fstab(void) {
2209 std::vector<TWPartition*>::iterator iter;
2210 char storage_partition[255];
2211 string Temp;
bigbiff bigbiff19874f12019-01-08 20:06:57 -05002212
2213 std::string storageFstab = TWFunc::get_cache_dir() + "recovery/storage.fstab";
2214 FILE *fp = fopen(storageFstab.c_str(), "w");
Dees_Troyd93bda52013-07-03 19:55:19 +00002215
2216 if (fp == NULL) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -05002217 gui_msg(Msg(msg::kError, "unable_to_open=Unable to open '{1}'.")(storageFstab));
Dees_Troyd93bda52013-07-03 19:55:19 +00002218 return;
2219 }
2220
2221 // Iterate through all partitions
2222 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2223 if ((*iter)->Is_Storage) {
2224 Temp = (*iter)->Storage_Path + ";" + (*iter)->Storage_Name + ";\n";
2225 strcpy(storage_partition, Temp.c_str());
2226 fwrite(storage_partition, sizeof(storage_partition[0]), strlen(storage_partition) / sizeof(storage_partition[0]), fp);
2227 }
2228 }
2229 fclose(fp);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002230}
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002231
2232TWPartition *TWPartitionManager::Get_Default_Storage_Partition()
2233{
2234 TWPartition *res = NULL;
2235 for (std::vector<TWPartition*>::iterator iter = Partitions.begin(); iter != Partitions.end(); ++iter) {
Matt Mowera8a89d12016-12-30 18:10:37 -06002236 if (!(*iter)->Is_Storage)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002237 continue;
2238
Matt Mowera8a89d12016-12-30 18:10:37 -06002239 if ((*iter)->Is_Settings_Storage)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002240 return *iter;
2241
Matt Mowera8a89d12016-12-30 18:10:37 -06002242 if (!res)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002243 res = *iter;
2244 }
2245 return res;
2246}
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002247
2248bool TWPartitionManager::Enable_MTP(void) {
2249#ifdef TW_HAS_MTP
Ethan Yonker8dfa7772014-09-04 21:48:41 -05002250 if (mtppid) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002251 gui_err("mtp_already_enabled=MTP already enabled");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002252 return true;
2253 }
Ethan Yonker726a0202014-12-16 20:01:38 -06002254
2255 int mtppipe[2];
2256
2257 if (pipe(mtppipe) < 0) {
2258 LOGERR("Error creating MTP pipe\n");
2259 return false;
2260 }
2261
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002262 char old_value[PROPERTY_VALUE_MAX];
Matt Mowere07f0102017-02-23 17:40:00 -06002263 property_get("sys.usb.config", old_value, "");
2264 if (strcmp(old_value, "mtp,adb") != 0) {
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002265 char vendor[PROPERTY_VALUE_MAX];
2266 char product[PROPERTY_VALUE_MAX];
2267 property_set("sys.usb.config", "none");
2268 property_get("usb.vendor", vendor, "18D1");
2269 property_get("usb.product.mtpadb", product, "4EE2");
2270 string vendorstr = vendor;
2271 string productstr = product;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002272 TWFunc::write_to_file("/sys/class/android_usb/android0/idVendor", vendorstr);
2273 TWFunc::write_to_file("/sys/class/android_usb/android0/idProduct", productstr);
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002274 property_set("sys.usb.config", "mtp,adb");
2275 }
Matt Mower653a1702017-02-16 10:38:52 -06002276 /* To enable MTP debug, use the twrp command line feature:
Ethan Yonker6d154c42014-09-03 14:19:43 -05002277 * twrp set tw_mtp_debug 1
2278 */
2279 twrpMtp *mtp = new twrpMtp(DataManager::GetIntValue("tw_mtp_debug"));
Ethan Yonker1b039202015-01-30 10:08:48 -06002280 mtppid = mtp->forkserver(mtppipe);
2281 if (mtppid) {
2282 close(mtppipe[0]); // Host closes read side
2283 mtp_write_fd = mtppipe[1];
2284 DataManager::SetValue("tw_mtp_enabled", 1);
2285 Add_All_MTP_Storage();
2286 return true;
Ethan Yonker726a0202014-12-16 20:01:38 -06002287 } else {
2288 close(mtppipe[0]);
2289 close(mtppipe[1]);
Ethan Yonker74db1572015-10-28 12:44:49 -05002290 gui_err("mtp_fail=Failed to enable MTP");
Ethan Yonker1b039202015-01-30 10:08:48 -06002291 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002292 }
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002293#else
Ethan Yonker74db1572015-10-28 12:44:49 -05002294 gui_err("no_mtp=MTP support not included");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002295#endif
2296 DataManager::SetValue("tw_mtp_enabled", 0);
2297 return false;
2298}
2299
Ethan Yonker1b039202015-01-30 10:08:48 -06002300void TWPartitionManager::Add_All_MTP_Storage(void) {
2301#ifdef TW_HAS_MTP
2302 std::vector<TWPartition*>::iterator iter;
2303
2304 if (!mtppid)
2305 return; // MTP is not enabled
2306
2307 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2308 if ((*iter)->Is_Storage && (*iter)->Is_Present && (*iter)->Mount(false))
2309 Add_Remove_MTP_Storage((*iter), MTP_MESSAGE_ADD_STORAGE);
2310 }
2311#else
2312 return;
2313#endif
2314}
2315
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002316bool TWPartitionManager::Disable_MTP(void) {
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002317 char old_value[PROPERTY_VALUE_MAX];
Matt Mowere07f0102017-02-23 17:40:00 -06002318 property_get("sys.usb.config", old_value, "");
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002319 if (strcmp(old_value, "adb") != 0) {
2320 char vendor[PROPERTY_VALUE_MAX];
2321 char product[PROPERTY_VALUE_MAX];
2322 property_set("sys.usb.config", "none");
2323 property_get("usb.vendor", vendor, "18D1");
Matt Mowere07f0102017-02-23 17:40:00 -06002324 property_get("usb.product.adb", product, "D001");
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002325 string vendorstr = vendor;
2326 string productstr = product;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002327 TWFunc::write_to_file("/sys/class/android_usb/android0/idVendor", vendorstr);
2328 TWFunc::write_to_file("/sys/class/android_usb/android0/idProduct", productstr);
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002329 usleep(2000);
2330 }
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002331#ifdef TW_HAS_MTP
Ethan Yonker8dfa7772014-09-04 21:48:41 -05002332 if (mtppid) {
Ethan Yonker8613dc02014-09-11 09:28:20 -05002333 LOGINFO("Disabling MTP\n");
2334 int status;
2335 kill(mtppid, SIGKILL);
Ethan Yonker8dfa7772014-09-04 21:48:41 -05002336 mtppid = 0;
Ethan Yonker8613dc02014-09-11 09:28:20 -05002337 // We don't care about the exit value, but this prevents a zombie process
2338 waitpid(mtppid, &status, 0);
Ethan Yonker726a0202014-12-16 20:01:38 -06002339 close(mtp_write_fd);
2340 mtp_write_fd = -1;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002341 }
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002342#endif
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002343 property_set("sys.usb.config", "adb");
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002344#ifdef TW_HAS_MTP
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002345 DataManager::SetValue("tw_mtp_enabled", 0);
2346 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002347#endif
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002348 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002349}
Ethan Yonker726a0202014-12-16 20:01:38 -06002350
2351TWPartition* TWPartitionManager::Find_Partition_By_MTP_Storage_ID(unsigned int Storage_ID) {
2352 std::vector<TWPartition*>::iterator iter;
2353
2354 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2355 if ((*iter)->MTP_Storage_ID == Storage_ID)
2356 return (*iter);
2357 }
2358 return NULL;
2359}
2360
2361bool TWPartitionManager::Add_Remove_MTP_Storage(TWPartition* Part, int message_type) {
2362#ifdef TW_HAS_MTP
2363 struct mtpmsg mtp_message;
2364
2365 if (!mtppid)
2366 return false; // MTP is disabled
2367
2368 if (mtp_write_fd < 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002369 LOGINFO("MTP: mtp_write_fd is not set\n");
Ethan Yonker726a0202014-12-16 20:01:38 -06002370 return false;
2371 }
2372
2373 if (Part) {
Ethan Yonker4bfabab2014-12-29 09:15:37 -06002374 if (Part->MTP_Storage_ID == 0)
2375 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002376 if (message_type == MTP_MESSAGE_REMOVE_STORAGE) {
2377 mtp_message.message_type = MTP_MESSAGE_REMOVE_STORAGE; // Remove
2378 LOGINFO("sending message to remove %i\n", Part->MTP_Storage_ID);
2379 mtp_message.storage_id = Part->MTP_Storage_ID;
2380 if (write(mtp_write_fd, &mtp_message, sizeof(mtp_message)) <= 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002381 LOGINFO("error sending message to remove storage %i\n", Part->MTP_Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002382 return false;
2383 } else {
2384 LOGINFO("Message sent, remove storage ID: %i\n", Part->MTP_Storage_ID);
2385 return true;
2386 }
2387 } else if (message_type == MTP_MESSAGE_ADD_STORAGE && Part->Is_Mounted()) {
2388 mtp_message.message_type = MTP_MESSAGE_ADD_STORAGE; // Add
2389 mtp_message.storage_id = Part->MTP_Storage_ID;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002390 if (Part->Storage_Path.size() >= sizeof(mtp_message.path)) {
2391 LOGERR("Storage path '%s' too large for mtpmsg\n", Part->Storage_Path.c_str());
2392 return false;
2393 }
2394 strcpy(mtp_message.path, Part->Storage_Path.c_str());
2395 if (Part->Storage_Name.size() >= sizeof(mtp_message.display)) {
2396 LOGERR("Storage name '%s' too large for mtpmsg\n", Part->Storage_Name.c_str());
2397 return false;
2398 }
2399 strcpy(mtp_message.display, Part->Storage_Name.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -06002400 mtp_message.maxFileSize = Part->Get_Max_FileSize();
Ethan Yonker1b039202015-01-30 10:08:48 -06002401 LOGINFO("sending message to add %i '%s' '%s'\n", mtp_message.storage_id, mtp_message.path, mtp_message.display);
Ethan Yonker726a0202014-12-16 20:01:38 -06002402 if (write(mtp_write_fd, &mtp_message, sizeof(mtp_message)) <= 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002403 LOGINFO("error sending message to add storage %i\n", Part->MTP_Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002404 return false;
2405 } else {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002406 LOGINFO("Message sent, add storage ID: %i '%s'\n", Part->MTP_Storage_ID, mtp_message.path);
Ethan Yonker726a0202014-12-16 20:01:38 -06002407 return true;
2408 }
2409 } else {
2410 LOGERR("Unknown MTP message type: %i\n", message_type);
2411 }
2412 } else {
2413 // This hopefully never happens as the error handling should
2414 // occur in the calling function.
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002415 LOGINFO("TWPartitionManager::Add_Remove_MTP_Storage NULL partition given\n");
Ethan Yonker726a0202014-12-16 20:01:38 -06002416 }
2417 return true;
2418#else
Ethan Yonker74db1572015-10-28 12:44:49 -05002419 gui_err("no_mtp=MTP support not included");
Ethan Yonker726a0202014-12-16 20:01:38 -06002420 DataManager::SetValue("tw_mtp_enabled", 0);
2421 return false;
2422#endif
2423}
2424
2425bool TWPartitionManager::Add_MTP_Storage(string Mount_Point) {
2426#ifdef TW_HAS_MTP
2427 TWPartition* Part = PartitionManager.Find_Partition_By_Path(Mount_Point);
2428 if (Part) {
2429 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_ADD_STORAGE);
2430 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002431 LOGINFO("TWFunc::Add_MTP_Storage unable to locate partition for '%s'\n", Mount_Point.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -06002432 }
2433#endif
2434 return false;
2435}
2436
2437bool TWPartitionManager::Add_MTP_Storage(unsigned int Storage_ID) {
2438#ifdef TW_HAS_MTP
2439 TWPartition* Part = PartitionManager.Find_Partition_By_MTP_Storage_ID(Storage_ID);
2440 if (Part) {
2441 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_ADD_STORAGE);
2442 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002443 LOGINFO("TWFunc::Add_MTP_Storage unable to locate partition for %i\n", Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002444 }
2445#endif
2446 return false;
2447}
2448
2449bool TWPartitionManager::Remove_MTP_Storage(string Mount_Point) {
2450#ifdef TW_HAS_MTP
2451 TWPartition* Part = PartitionManager.Find_Partition_By_Path(Mount_Point);
2452 if (Part) {
2453 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_REMOVE_STORAGE);
2454 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002455 LOGINFO("TWFunc::Remove_MTP_Storage unable to locate partition for '%s'\n", Mount_Point.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -06002456 }
2457#endif
2458 return false;
2459}
2460
2461bool TWPartitionManager::Remove_MTP_Storage(unsigned int Storage_ID) {
2462#ifdef TW_HAS_MTP
2463 TWPartition* Part = PartitionManager.Find_Partition_By_MTP_Storage_ID(Storage_ID);
2464 if (Part) {
2465 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_REMOVE_STORAGE);
2466 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002467 LOGINFO("TWFunc::Remove_MTP_Storage unable to locate partition for %i\n", Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002468 }
2469#endif
2470 return false;
2471}
Ethan Yonker96af84a2015-01-05 14:58:36 -06002472
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002473bool TWPartitionManager::Flash_Image(string& path, string& filename) {
Matt Mower23d8aae2017-01-06 14:30:33 -06002474 int partition_count = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002475 TWPartition* flash_part = NULL;
bigbiffce8f83c2015-12-12 18:30:21 -05002476 string Flash_List, flash_path, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002477 size_t start_pos = 0, end_pos = 0;
2478
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002479 full_filename = path + "/" + filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002480
bigbiffce8f83c2015-12-12 18:30:21 -05002481 gui_msg("image_flash_start=[IMAGE FLASH STARTED]");
2482 gui_msg(Msg("img_to_flash=Image to flash: '{1}'")(full_filename));
2483
2484 if (!TWFunc::Path_Exists(full_filename)) {
2485 if (!Mount_By_Path(full_filename, true)) {
Ethan Yonkerb78fbdf2016-01-15 16:46:35 -06002486 return false;
2487 }
bigbiffce8f83c2015-12-12 18:30:21 -05002488 if (!TWFunc::Path_Exists(full_filename)) {
2489 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")(full_filename));
Ethan Yonkerb78fbdf2016-01-15 16:46:35 -06002490 return false;
2491 }
2492 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002493
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002494 PartitionSettings part_settings;
2495 part_settings.Backup_Folder = path;
2496 unsigned long long total_bytes = TWFunc::Get_File_Size(full_filename);
2497 ProgressTracking progress(total_bytes);
2498 part_settings.progress = &progress;
2499 part_settings.adbbackup = false;
2500 part_settings.PM_Method = PM_RESTORE;
2501
Ethan Yonker74db1572015-10-28 12:44:49 -05002502 gui_msg("calc_restore=Calculating restore details...");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002503 DataManager::GetValue("tw_flash_partition", Flash_List);
2504 if (!Flash_List.empty()) {
2505 end_pos = Flash_List.find(";", start_pos);
2506 while (end_pos != string::npos && start_pos < Flash_List.size()) {
2507 flash_path = Flash_List.substr(start_pos, end_pos - start_pos);
2508 flash_part = Find_Partition_By_Path(flash_path);
2509 if (flash_part != NULL) {
2510 partition_count++;
2511 if (partition_count > 1) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002512 gui_err("too_many_flash=Too many partitions selected for flashing.");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002513 return false;
2514 }
2515 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002516 gui_msg(Msg(msg::kError, "flash_unable_locate=Unable to locate '{1}' partition for flashing.")(flash_path));
Ethan Yonker96af84a2015-01-05 14:58:36 -06002517 return false;
2518 }
2519 start_pos = end_pos + 1;
2520 end_pos = Flash_List.find(";", start_pos);
2521 }
2522 }
2523
2524 if (partition_count == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002525 gui_err("no_part_flash=No partitions selected for flashing.");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002526 return false;
2527 }
2528
2529 DataManager::SetProgress(0.0);
2530 if (flash_part) {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002531 flash_part->Backup_FileName = filename;
2532 if (!flash_part->Flash_Image(&part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002533 return false;
2534 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002535 gui_err("invalid_flash=Invalid flash partition specified.");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002536 return false;
2537 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002538 gui_highlight("flash_done=IMAGE FLASH COMPLETED]");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002539 return true;
2540}
Ethan Yonker74db1572015-10-28 12:44:49 -05002541
2542void TWPartitionManager::Translate_Partition(const char* path, const char* resource_name, const char* default_value) {
2543 TWPartition* part = PartitionManager.Find_Partition_By_Path(path);
2544 if (part) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002545 if (part->Is_Adopted_Storage) {
2546 part->Display_Name = part->Display_Name + " - " + gui_lookup("data", "Data");
2547 part->Backup_Display_Name = part->Display_Name;
2548 part->Storage_Name = part->Storage_Name + " - " + gui_lookup("adopted_storage", "Adopted Storage");
2549 } else {
2550 part->Display_Name = gui_lookup(resource_name, default_value);
2551 part->Backup_Display_Name = part->Display_Name;
2552 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002553 }
2554}
2555
2556void TWPartitionManager::Translate_Partition(const char* path, const char* resource_name, const char* default_value, const char* storage_resource_name, const char* storage_default_value) {
2557 TWPartition* part = PartitionManager.Find_Partition_By_Path(path);
2558 if (part) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002559 if (part->Is_Adopted_Storage) {
Ethan Yonker01f4e032017-02-03 15:30:52 -06002560 part->Backup_Display_Name = part->Display_Name + " - " + gui_lookup("data_backup", "Data (excl. storage)");
Ethan Yonker66a19492015-12-10 10:19:45 -06002561 part->Display_Name = part->Display_Name + " - " + gui_lookup("data", "Data");
Ethan Yonker66a19492015-12-10 10:19:45 -06002562 part->Storage_Name = part->Storage_Name + " - " + gui_lookup("adopted_storage", "Adopted Storage");
2563 } else {
2564 part->Display_Name = gui_lookup(resource_name, default_value);
2565 part->Backup_Display_Name = part->Display_Name;
2566 if (part->Is_Storage)
2567 part->Storage_Name = gui_lookup(storage_resource_name, storage_default_value);
2568 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002569 }
2570}
2571
Ethan Yonker01f4e032017-02-03 15:30:52 -06002572void TWPartitionManager::Translate_Partition(const char* path, const char* resource_name, const char* default_value, const char* storage_resource_name, const char* storage_default_value, const char* backup_name, const char* backup_default) {
2573 TWPartition* part = PartitionManager.Find_Partition_By_Path(path);
2574 if (part) {
2575 if (part->Is_Adopted_Storage) {
2576 part->Backup_Display_Name = part->Display_Name + " - " + gui_lookup(backup_name, backup_default);
2577 part->Display_Name = part->Display_Name + " - " + gui_lookup("data", "Data");
2578 part->Storage_Name = part->Storage_Name + " - " + gui_lookup("adopted_storage", "Adopted Storage");
2579 } else {
2580 part->Display_Name = gui_lookup(resource_name, default_value);
2581 part->Backup_Display_Name = gui_lookup(backup_name, backup_default);
2582 if (part->Is_Storage)
2583 part->Storage_Name = gui_lookup(storage_resource_name, storage_default_value);
2584 }
2585 }
2586}
2587
Ethan Yonker74db1572015-10-28 12:44:49 -05002588void TWPartitionManager::Translate_Partition_Display_Names() {
Ethan Yonker66a19492015-12-10 10:19:45 -06002589 LOGINFO("Translating partition display names\n");
Ethan Yonker74db1572015-10-28 12:44:49 -05002590 Translate_Partition("/system", "system", "System");
2591 Translate_Partition("/system_image", "system_image", "System Image");
2592 Translate_Partition("/vendor", "vendor", "Vendor");
2593 Translate_Partition("/vendor_image", "vendor_image", "Vendor Image");
2594 Translate_Partition("/cache", "cache", "Cache");
Ethan Yonker74db1572015-10-28 12:44:49 -05002595 Translate_Partition("/boot", "boot", "Boot");
2596 Translate_Partition("/recovery", "recovery", "Recovery");
2597 if (!datamedia) {
Ethan Yonker01f4e032017-02-03 15:30:52 -06002598 Translate_Partition("/data", "data", "Data", "internal", "Internal Storage");
Ethan Yonker74db1572015-10-28 12:44:49 -05002599 Translate_Partition("/sdcard", "sdcard", "SDCard", "sdcard", "SDCard");
2600 Translate_Partition("/internal_sd", "sdcard", "SDCard", "sdcard", "SDCard");
2601 Translate_Partition("/internal_sdcard", "sdcard", "SDCard", "sdcard", "SDCard");
2602 Translate_Partition("/emmc", "sdcard", "SDCard", "sdcard", "SDCard");
Ethan Yonker01f4e032017-02-03 15:30:52 -06002603 } else {
2604 Translate_Partition("/data", "data", "Data", "internal", "Internal Storage", "data_backup", "Data (excl. storage)");
Ethan Yonker74db1572015-10-28 12:44:49 -05002605 }
Ethan Yonker01f4e032017-02-03 15:30:52 -06002606 Translate_Partition("/external_sd", "microsd", "Micro SDCard", "microsd", "Micro SDCard", "data_backup", "Data (excl. storage)");
2607 Translate_Partition("/external_sdcard", "microsd", "Micro SDCard", "microsd", "Micro SDCard", "data_backup", "Data (excl. storage)");
Ethan Yonker74db1572015-10-28 12:44:49 -05002608 Translate_Partition("/usb-otg", "usbotg", "USB OTG", "usbotg", "USB OTG");
2609 Translate_Partition("/sd-ext", "sdext", "SD-EXT");
2610
2611 // Android secure is a special case
2612 TWPartition* part = PartitionManager.Find_Partition_By_Path("/and-sec");
2613 if (part)
2614 part->Backup_Display_Name = gui_lookup("android_secure", "Android Secure");
2615
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002616 std::vector<TWPartition*>::iterator sysfs;
2617 for (sysfs = Partitions.begin(); sysfs != Partitions.end(); sysfs++) {
2618 if (!(*sysfs)->Sysfs_Entry.empty()) {
2619 Translate_Partition((*sysfs)->Mount_Point.c_str(), "autostorage", "Storage", "autostorage", "Storage");
2620 }
2621 }
2622
Ethan Yonker74db1572015-10-28 12:44:49 -05002623 // This updates the text on all of the storage selection buttons in the GUI
2624 DataManager::SetBackupFolder();
2625}
Ethan Yonker66a19492015-12-10 10:19:45 -06002626
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002627bool TWPartitionManager::Decrypt_Adopted() {
Ethan Yonker66a19492015-12-10 10:19:45 -06002628#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002629 bool ret = false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002630 if (!Mount_By_Path("/data", false)) {
2631 LOGERR("Cannot decrypt adopted storage because /data will not mount\n");
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002632 return false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002633 }
2634 LOGINFO("Decrypt adopted storage starting\n");
2635 char* xmlFile = PageManager::LoadFileToBuffer("/data/system/storage.xml", NULL);
2636 xml_document<> *doc = NULL;
2637 xml_node<>* volumes = NULL;
Ethan Yonker66a19492015-12-10 10:19:45 -06002638 string Primary_Storage_UUID = "";
2639 if (xmlFile != NULL) {
2640 LOGINFO("successfully loaded storage.xml\n");
2641 doc = new xml_document<>();
2642 doc->parse<0>(xmlFile);
2643 volumes = doc->first_node("volumes");
2644 if (volumes) {
2645 xml_attribute<>* psuuid = volumes->first_attribute("primaryStorageUuid");
2646 if (psuuid) {
2647 Primary_Storage_UUID = psuuid->value();
2648 }
2649 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002650 } else {
2651 LOGINFO("No /data/system/storage.xml for adopted storage\n");
2652 return false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002653 }
2654 std::vector<TWPartition*>::iterator adopt;
2655 for (adopt = Partitions.begin(); adopt != Partitions.end(); adopt++) {
2656 if ((*adopt)->Removable && (*adopt)->Is_Present) {
2657 if ((*adopt)->Decrypt_Adopted() == 0) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002658 ret = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06002659 if (volumes) {
2660 xml_node<>* volume = volumes->first_node("volume");
2661 while (volume) {
2662 xml_attribute<>* guid = volume->first_attribute("partGuid");
2663 if (guid) {
2664 string GUID = (*adopt)->Adopted_GUID.c_str();
2665 GUID.insert(8, "-");
2666 GUID.insert(13, "-");
2667 GUID.insert(18, "-");
2668 GUID.insert(23, "-");
2669
2670 if (strcasecmp(GUID.c_str(), guid->value()) == 0) {
2671 xml_attribute<>* attr = volume->first_attribute("nickname");
nkk71ffb02bd2017-06-04 23:12:16 +03002672 if (attr && attr->value() && strlen(attr->value()) > 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002673 (*adopt)->Storage_Name = attr->value();
2674 (*adopt)->Display_Name = (*adopt)->Storage_Name;
2675 (*adopt)->Backup_Display_Name = (*adopt)->Storage_Name;
2676 LOGINFO("storage name from storage.xml is '%s'\n", attr->value());
2677 }
2678 attr = volume->first_attribute("fsUuid");
2679 if (attr && !Primary_Storage_UUID.empty() && strcmp(Primary_Storage_UUID.c_str(), attr->value()) == 0) {
2680 TWPartition* Dat = Find_Partition_By_Path("/data");
2681 if (Dat) {
2682 LOGINFO("Internal storage is found on adopted storage '%s'\n", (*adopt)->Display_Name.c_str());
2683 LOGINFO("Changing '%s' to point to '%s'\n", Dat->Symlink_Mount_Point.c_str(), (*adopt)->Storage_Path.c_str());
2684 (*adopt)->Symlink_Mount_Point = Dat->Symlink_Mount_Point;
2685 Dat->Symlink_Mount_Point = "";
2686 // Toggle mounts to ensure that the symlink mount point (probably /sdcard) is mounted to the right location
2687 Dat->UnMount(false);
2688 Dat->Mount(false);
2689 (*adopt)->UnMount(false);
2690 (*adopt)->Mount(false);
Ethan Yonker66a19492015-12-10 10:19:45 -06002691 }
2692 }
2693 break;
2694 }
2695 }
2696 volume = volume->next_sibling("volume");
2697 }
2698 }
nkk71ffb02bd2017-06-04 23:12:16 +03002699 Update_System_Details();
2700 Output_Partition((*adopt));
Ethan Yonker66a19492015-12-10 10:19:45 -06002701 }
2702 }
2703 }
2704 if (xmlFile) {
2705 doc->clear();
2706 delete doc;
2707 free(xmlFile);
2708 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002709 return ret;
Ethan Yonker66a19492015-12-10 10:19:45 -06002710#else
2711 LOGINFO("Decrypt_Adopted: no crypto support\n");
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002712 return false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002713#endif
2714}
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06002715
2716void TWPartitionManager::Remove_Partition_By_Path(string Path) {
2717 std::vector<TWPartition*>::iterator iter;
2718 string Local_Path = TWFunc::Get_Root_Path(Path);
2719
2720 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2721 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
2722 LOGINFO("Found and erasing '%s' from partition list\n", Local_Path.c_str());
2723 Partitions.erase(iter);
2724 return;
2725 }
2726 }
2727}
Ethan Yonker1b190162016-12-05 15:25:19 -06002728
2729void TWPartitionManager::Set_Active_Slot(const string& Slot) {
2730 if (Slot != "A" && Slot != "B") {
2731 LOGERR("Set_Active_Slot invalid slot '%s'\n", Slot.c_str());
2732 return;
2733 }
2734 if (Active_Slot_Display == Slot)
2735 return;
2736 LOGINFO("Setting active slot %s\n", Slot.c_str());
2737#ifdef AB_OTA_UPDATER
2738 if (!Active_Slot_Display.empty()) {
2739 const hw_module_t *hw_module;
2740 boot_control_module_t *module;
2741 int ret;
2742 ret = hw_get_module("bootctrl", &hw_module);
2743 if (ret != 0) {
2744 LOGERR("Error getting bootctrl module.\n");
2745 } else {
2746 module = (boot_control_module_t*) hw_module;
2747 module->init(module);
2748 int slot_number = 0;
2749 if (Slot == "B")
2750 slot_number = 1;
2751 if (module->setActiveBootSlot(module, slot_number))
2752 gui_msg(Msg(msg::kError, "unable_set_boot_slot=Error changing bootloader boot slot to {1}")(Slot));
2753 }
2754 DataManager::SetValue("tw_active_slot", Slot); // Doing this outside of this if block may result in a seg fault because the DataManager may not be ready yet
2755 }
2756#else
2757 LOGERR("Boot slot feature not present\n");
2758#endif
2759 Active_Slot_Display = Slot;
2760 if (Fstab_Processed())
2761 Update_System_Details();
2762}
2763string TWPartitionManager::Get_Active_Slot_Suffix() {
2764 if (Active_Slot_Display == "A")
2765 return "_a";
2766 return "_b";
2767}
2768string TWPartitionManager::Get_Active_Slot_Display() {
2769 return Active_Slot_Display;
2770}
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002771
Captain Throwback9d6feb52018-07-27 10:05:24 -04002772string TWPartitionManager::Get_Android_Root_Path() {
2773 std::string Android_Root = getenv("ANDROID_ROOT");
2774 if (Android_Root == "")
2775 Android_Root = "/system";
2776 return Android_Root;
2777}
2778
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002779void TWPartitionManager::Remove_Uevent_Devices(const string& Mount_Point) {
2780 std::vector<TWPartition*>::iterator iter;
2781
2782 for (iter = Partitions.begin(); iter != Partitions.end(); ) {
2783 if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Mount_Point) {
2784 TWPartition *part = *iter;
2785 LOGINFO("%s was removed by uevent data\n", (*iter)->Mount_Point.c_str());
2786 (*iter)->UnMount(false);
2787 rmdir((*iter)->Mount_Point.c_str());
2788 iter = Partitions.erase(iter);
2789 delete part;
2790 } else {
2791 iter++;
2792 }
2793 }
2794}
2795
2796void TWPartitionManager::Handle_Uevent(const Uevent_Block_Data& uevent_data) {
2797 std::vector<TWPartition*>::iterator iter;
2798
2799 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2800 if (!(*iter)->Sysfs_Entry.empty()) {
2801 string device;
2802 size_t wildcard = (*iter)->Sysfs_Entry.find("*");
2803 if (wildcard != string::npos) {
2804 device = (*iter)->Sysfs_Entry.substr(0, wildcard);
2805 } else {
2806 device = (*iter)->Sysfs_Entry;
2807 }
2808 if (device == uevent_data.sysfs_path.substr(0, device.size())) {
2809 // Found a match
2810 if (uevent_data.action == "add") {
2811 (*iter)->Primary_Block_Device = "/dev/block/" + uevent_data.block_device;
2812 (*iter)->Alternate_Block_Device = (*iter)->Primary_Block_Device;
2813 (*iter)->Is_Present = true;
2814 LOGINFO("Found a match '%s' '%s'\n", uevent_data.block_device.c_str(), device.c_str());
2815 if (!Decrypt_Adopted()) {
2816 LOGINFO("No adopted storage so finding actual block device\n");
2817 (*iter)->Find_Actual_Block_Device();
2818 }
2819 return;
2820 } else if (uevent_data.action == "remove") {
2821 (*iter)->Is_Present = false;
2822 (*iter)->Primary_Block_Device = "";
2823 (*iter)->Actual_Block_Device = "";
2824 Remove_Uevent_Devices((*iter)->Mount_Point);
2825 return;
2826 }
2827 }
2828 }
2829 }
2830 LOGINFO("Found no matching fstab entry for uevent device '%s' - %s\n", uevent_data.sysfs_path.c_str(), uevent_data.action.c_str());
2831}
2832
2833void TWPartitionManager::setup_uevent() {
2834 struct sockaddr_nl nls;
2835
2836 if (uevent_pfd.fd >= 0) {
2837 LOGINFO("uevent already set up\n");
2838 return;
2839 }
2840
2841 // Open hotplug event netlink socket
2842 memset(&nls,0,sizeof(struct sockaddr_nl));
2843 nls.nl_family = AF_NETLINK;
2844 nls.nl_pid = getpid();
2845 nls.nl_groups = -1;
2846 uevent_pfd.events = POLLIN;
2847 uevent_pfd.fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
2848 if (uevent_pfd.fd==-1) {
2849 LOGERR("uevent not root\n");
2850 return;
2851 }
2852
2853 // Listen to netlink socket
2854 if (::bind(uevent_pfd.fd, (struct sockaddr *) &nls, sizeof(struct sockaddr_nl)) < 0) {
2855 LOGERR("Bind failed\n");
2856 return;
2857 }
2858 set_select_fd();
2859 Coldboot();
2860}
2861
2862Uevent_Block_Data TWPartitionManager::get_event_block_values(char *buf, int len) {
2863 Uevent_Block_Data ret;
2864 ret.subsystem = "";
2865 char *ptr = buf;
2866 const char *end = buf + len;
2867
2868 buf[len - 1] = '\0';
2869 while (ptr < end) {
2870 if (strncmp(ptr, "ACTION=", strlen("ACTION=")) == 0) {
2871 ptr += strlen("ACTION=");
2872 ret.action = ptr;
2873 } else if (strncmp(ptr, "SUBSYSTEM=", strlen("SUBSYSTEM=")) == 0) {
2874 ptr += strlen("SUBSYSTEM=");
2875 ret.subsystem = ptr;
2876 } else if (strncmp(ptr, "DEVTYPE=", strlen("DEVTYPE=")) == 0) {
2877 ptr += strlen("DEVTYPE=");
2878 ret.type = ptr;
2879 } else if (strncmp(ptr, "DEVPATH=", strlen("DEVPATH=")) == 0) {
2880 ptr += strlen("DEVPATH=");
2881 ret.sysfs_path += ptr;
2882 } else if (strncmp(ptr, "DEVNAME=", strlen("DEVNAME=")) == 0) {
2883 ptr += strlen("DEVNAME=");
2884 ret.block_device += ptr;
2885 } else if (strncmp(ptr, "MAJOR=", strlen("MAJOR=")) == 0) {
2886 ptr += strlen("MAJOR=");
2887 ret.major = atoi(ptr);
2888 } else if (strncmp(ptr, "MINOR=", strlen("MINOR=")) == 0) {
2889 ptr += strlen("MINOR=");
2890 ret.minor = atoi(ptr);
2891 }
2892 ptr += strlen(ptr) + 1;
2893 }
2894 return ret;
2895}
2896
2897void TWPartitionManager::read_uevent() {
2898 char buf[1024];
2899
2900 int len = recv(uevent_pfd.fd, buf, sizeof(buf), MSG_DONTWAIT);
2901 if (len == -1) {
2902 LOGERR("recv error on uevent\n");
2903 return;
2904 }
2905 /*int i = 0; // Print all uevent output for test /debug
2906 while (i<len) {
2907 printf("%s\n", buf+i);
2908 i += strlen(buf+i)+1;
2909 }*/
2910 Uevent_Block_Data uevent_data = get_event_block_values(buf, len);
2911 if (uevent_data.subsystem == "block" && uevent_data.type == "disk") {
2912 PartitionManager.Handle_Uevent(uevent_data);
2913 }
2914}
2915
2916void TWPartitionManager::close_uevent() {
2917 if (uevent_pfd.fd > 0)
2918 close(uevent_pfd.fd);
2919 uevent_pfd.fd = -1;
2920}
2921
2922void TWPartitionManager::Add_Partition(TWPartition* Part) {
2923 Partitions.push_back(Part);
2924}
2925
2926void TWPartitionManager::Coldboot_Scan(std::vector<string> *sysfs_entries, const string& Path, int depth) {
2927 string Real_Path = Path;
2928 char real_path[PATH_MAX];
2929 if (realpath(Path.c_str(), &real_path[0])) {
2930 string Real_Path = real_path;
2931 std::vector<string>::iterator iter;
2932 for (iter = sysfs_entries->begin(); iter != sysfs_entries->end(); iter++) {
2933 if (Real_Path.find((*iter)) != string::npos) {
2934 string Write_Path = Real_Path + "/uevent";
2935 if (TWFunc::Path_Exists(Write_Path)) {
2936 const char* write_val = "add\n";
2937 TWFunc::write_to_file(Write_Path, write_val);
2938 break;
2939 }
2940 }
2941 }
2942 }
2943
2944 DIR* d = opendir(Path.c_str());
2945 if (d != NULL) {
2946 struct dirent* de;
2947 while ((de = readdir(d)) != NULL) {
2948 if (de->d_name[0] == '.' || (de->d_type != DT_DIR && depth > 0))
2949 continue;
2950 if (strlen(de->d_name) >= 4 && (strncmp(de->d_name, "ram", 3) == 0 || strncmp(de->d_name, "loop", 4) == 0))
2951 continue;
2952
2953 string item = Path + "/";
2954 item.append(de->d_name);
2955 Coldboot_Scan(sysfs_entries, item, depth + 1);
2956 }
2957 closedir(d);
2958 }
2959}
2960
2961void TWPartitionManager::Coldboot() {
2962 std::vector<TWPartition*>::iterator iter;
2963 std::vector<string> sysfs_entries;
2964
2965 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2966 if (!(*iter)->Sysfs_Entry.empty()) {
2967 size_t wildcard_pos = (*iter)->Sysfs_Entry.find("*");
2968 if (wildcard_pos == string::npos)
2969 wildcard_pos = (*iter)->Sysfs_Entry.size();
2970 sysfs_entries.push_back((*iter)->Sysfs_Entry.substr(0, wildcard_pos));
2971 }
2972 }
2973
2974 if (sysfs_entries.size() > 0)
2975 Coldboot_Scan(&sysfs_entries, "/sys/block", 0);
2976}