blob: da407fa69bd578cdab1e3537d57e5db991ed4729 [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"
74 #endif
nkk7171c6c502017-01-05 23:55:05 +020075 #ifdef TW_CRYPTO_USE_SYSTEM_VOLD
76 #include "crypto/vold_decrypt/vold_decrypt.h"
77 #endif
Dees_Troy5bf43922012-09-07 16:07:55 -040078#endif
Dees_Troy51a0e822012-09-05 15:24:24 -040079
Ethan Yonker1b190162016-12-05 15:25:19 -060080#ifdef AB_OTA_UPDATER
81#include <hardware/hardware.h>
82#include <hardware/boot_control.h>
83#endif
84
Ethan Yonker6277c792014-09-15 14:54:30 -050085extern bool datamedia;
86
bigbiff bigbiff34684ff2013-12-01 21:03:45 -050087TWPartitionManager::TWPartitionManager(void) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -040088 mtp_was_enabled = false;
Ethan Yonker726a0202014-12-16 20:01:38 -060089 mtp_write_fd = -1;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -060090 uevent_pfd.fd = -1;
bigbiff7abc5fe2015-01-17 16:53:12 -050091 stop_backup.set_value(0);
Ethan Yonker1b190162016-12-05 15:25:19 -060092#ifdef AB_OTA_UPDATER
93 char slot_suffix[PROPERTY_VALUE_MAX];
Ethan Yonkerfefe5912017-09-30 22:22:13 -050094 property_get("ro.boot.slot_suffix", slot_suffix, "error");
95 if (strcmp(slot_suffix, "error") == 0)
96 property_get("ro.boot.slot", slot_suffix, "error");
Ethan Yonker1b190162016-12-05 15:25:19 -060097 Active_Slot_Display = "";
Ethan Yonkerfefe5912017-09-30 22:22:13 -050098 if (strcmp(slot_suffix, "_a") == 0 || strcmp(slot_suffix, "a") == 0)
Ethan Yonker1b190162016-12-05 15:25:19 -060099 Set_Active_Slot("A");
100 else
101 Set_Active_Slot("B");
102#endif
bigbiff bigbiff34684ff2013-12-01 21:03:45 -0500103}
104
Dees_Troy51a0e822012-09-05 15:24:24 -0400105int TWPartitionManager::Process_Fstab(string Fstab_Filename, bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400106 FILE *fstabFile;
107 char fstab_line[MAX_FSTAB_LINE_LENGTH];
Dees Troy02a64532014-03-19 15:23:32 +0000108 TWPartition* settings_partition = NULL;
Matt Mowerbf4efa32014-04-14 23:25:26 -0500109 TWPartition* andsec_partition = NULL;
Ethan Yonker726a0202014-12-16 20:01:38 -0600110 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 -0600111 std::map<string, Flags_Map> twrp_flags;
112
113 fstabFile = fopen("/etc/twrp.flags", "rt");
114 if (fstabFile != NULL) {
115 LOGINFO("reading /etc/twrp.flags\n");
116 while (fgets(fstab_line, sizeof(fstab_line), fstabFile) != NULL) {
117 if (fstab_line[0] != '/')
118 continue;
119
120 size_t line_size = strlen(fstab_line);
121 if (fstab_line[line_size - 1] != '\n')
122 fstab_line[line_size] = '\n';
123 Flags_Map line_flags;
124 line_flags.Primary_Block_Device = "";
125 line_flags.Alternate_Block_Device = "";
126 line_flags.fstab_line = (char*)malloc(MAX_FSTAB_LINE_LENGTH);
127 if (!line_flags.fstab_line) {
128 LOGERR("malloc error on line_flags.fstab_line\n");
129 return false;
130 }
131 memcpy(line_flags.fstab_line, fstab_line, MAX_FSTAB_LINE_LENGTH);
132 bool found_separator = false;
133 char *fs_loc = NULL;
134 char *block_loc = NULL;
135 char *flags_loc = NULL;
136 size_t index, item_index = 0;
137 for (index = 0; index < line_size; index++) {
138 if (fstab_line[index] <= 32) {
139 fstab_line[index] = '\0';
140 found_separator = true;
141 } else if (found_separator) {
142 if (item_index == 0) {
143 fs_loc = fstab_line + index;
144 } else if (item_index == 1) {
145 block_loc = fstab_line + index;
146 } else if (item_index > 1) {
147 char *ptr = fstab_line + index;
148 if (*ptr == '/') {
149 line_flags.Alternate_Block_Device = ptr;
150 } else if (strlen(ptr) > strlen("flags=") && strncmp(ptr, "flags=", strlen("flags=")) == 0) {
151 flags_loc = ptr;
152 // Once we find the flags=, we're done scanning the line
153 break;
154 }
155 }
156 found_separator = false;
157 item_index++;
158 }
159 }
160 if (block_loc)
161 line_flags.Primary_Block_Device = block_loc;
162 if (fs_loc)
163 line_flags.File_System = fs_loc;
164 if (flags_loc)
165 line_flags.Flags = flags_loc;
166 string Mount_Point = fstab_line;
167 twrp_flags[Mount_Point] = line_flags;
168 memset(fstab_line, 0, sizeof(fstab_line));
169 }
170 fclose(fstabFile);
171 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400172
173 fstabFile = fopen(Fstab_Filename.c_str(), "rt");
174 if (fstabFile == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000175 LOGERR("Critical Error: Unable to open fstab at '%s'.\n", Fstab_Filename.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400176 return false;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600177 } else
178 LOGINFO("Reading %s\n", Fstab_Filename.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400179
180 while (fgets(fstab_line, sizeof(fstab_line), fstabFile) != NULL) {
181 if (fstab_line[0] != '/')
182 continue;
183
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600184 if (strstr(fstab_line, "swap"))
185 continue; // Skip swap in recovery
186
187 size_t line_size = strlen(fstab_line);
188 if (fstab_line[line_size - 1] != '\n')
189 fstab_line[line_size] = '\n';
Dees_Troy2a923582012-09-20 12:13:34 -0400190
Matt Mower2b2dd152016-04-26 11:24:08 -0500191 TWPartition* partition = new TWPartition();
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600192 if (partition->Process_Fstab_Line(fstab_line, Display_Error, &twrp_flags))
Ethan Yonkerc05c5982014-03-13 09:19:56 -0500193 Partitions.push_back(partition);
Matt Mower72c87ce2016-04-26 14:34:56 -0500194 else
Dees_Troy5bf43922012-09-07 16:07:55 -0400195 delete partition;
Matt Mower2b2dd152016-04-26 11:24:08 -0500196
197 memset(fstab_line, 0, sizeof(fstab_line));
Dees_Troy5bf43922012-09-07 16:07:55 -0400198 }
199 fclose(fstabFile);
Matt Mower72c87ce2016-04-26 14:34:56 -0500200
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600201 if (twrp_flags.size() > 0) {
202 LOGINFO("Processing remaining twrp.flags\n");
203 // Add any items from twrp.flags that did not exist in the recovery.fstab
204 for (std::map<string, Flags_Map>::iterator mapit=twrp_flags.begin(); mapit!=twrp_flags.end(); mapit++) {
205 if (Find_Partition_By_Path(mapit->first) == NULL) {
206 TWPartition* partition = new TWPartition();
207 if (partition->Process_Fstab_Line(mapit->second.fstab_line, Display_Error, NULL))
208 Partitions.push_back(partition);
209 else
210 delete partition;
211 }
212 if (mapit->second.fstab_line)
213 free(mapit->second.fstab_line);
214 mapit->second.fstab_line = NULL;
215 }
216 }
217 LOGINFO("Done processing fstab files\n");
218
Matt Mower72c87ce2016-04-26 14:34:56 -0500219 std::vector<TWPartition*>::iterator iter;
220 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
221 (*iter)->Partition_Post_Processing(Display_Error);
222
223 if ((*iter)->Is_Storage) {
224 ++storageid;
225 (*iter)->MTP_Storage_ID = storageid;
226 }
227
228 if (!settings_partition && (*iter)->Is_Settings_Storage && (*iter)->Is_Present)
229 settings_partition = (*iter);
230 else
231 (*iter)->Is_Settings_Storage = false;
232
233 if (!andsec_partition && (*iter)->Has_Android_Secure && (*iter)->Is_Present)
234 andsec_partition = (*iter);
235 else
236 (*iter)->Has_Android_Secure = false;
237 }
238
Ethan Yonker6277c792014-09-15 14:54:30 -0500239 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) {
240 // Attempt to automatically identify /data/media emulated storage devices
241 TWPartition* Dat = Find_Partition_By_Path("/data");
242 if (Dat) {
243 LOGINFO("Using automatic handling for /data/media emulated storage device.\n");
244 datamedia = true;
that9e0593e2014-10-08 00:01:24 +0200245 Dat->Setup_Data_Media();
Ethan Yonker6277c792014-09-15 14:54:30 -0500246 settings_partition = Dat;
Ethan Yonker726a0202014-12-16 20:01:38 -0600247 // Since /data was not considered a storage partition earlier, we still need to assign an MTP ID
248 ++storageid;
249 Dat->MTP_Storage_ID = storageid;
Ethan Yonker6277c792014-09-15 14:54:30 -0500250 }
251 }
Dees Troy02a64532014-03-19 15:23:32 +0000252 if (!settings_partition) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500253 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
254 if ((*iter)->Is_Storage) {
Dees Troy02a64532014-03-19 15:23:32 +0000255 settings_partition = (*iter);
Dees_Troya13d74f2013-03-24 08:54:55 -0500256 break;
257 }
258 }
Dees Troy02a64532014-03-19 15:23:32 +0000259 if (!settings_partition)
Dees_Troy2673cec2013-04-02 20:22:16 +0000260 LOGERR("Unable to locate storage partition for storing settings file.\n");
Dees_Troya13d74f2013-03-24 08:54:55 -0500261 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400262 if (!Write_Fstab()) {
263 if (Display_Error)
Dees_Troy2673cec2013-04-02 20:22:16 +0000264 LOGERR("Error creating fstab\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400265 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000266 LOGINFO("Error creating fstab\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400267 }
Matt Mowered71fa32014-04-16 13:21:47 -0500268
Matt Mowerbf4efa32014-04-14 23:25:26 -0500269 if (andsec_partition) {
270 Setup_Android_Secure_Location(andsec_partition);
Matt Mowered71fa32014-04-16 13:21:47 -0500271 } else if (settings_partition) {
Matt Mowerbf4efa32014-04-14 23:25:26 -0500272 Setup_Android_Secure_Location(settings_partition);
273 }
Matt Mowered71fa32014-04-16 13:21:47 -0500274 if (settings_partition) {
275 Setup_Settings_Storage_Partition(settings_partition);
276 }
Ethan Yonker253368a2014-11-25 15:00:52 -0600277#ifdef TW_INCLUDE_CRYPTO
Ethan Yonkercceebb82014-11-18 10:17:59 -0600278 TWPartition* Decrypt_Data = Find_Partition_By_Path("/data");
279 if (Decrypt_Data && Decrypt_Data->Is_Encrypted && !Decrypt_Data->Is_Decrypted) {
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600280 if (Decrypt_Data->Is_FBE) {
281 if (DataManager::GetIntValue(TW_CRYPTO_PWTYPE) == 0) {
282 if (Decrypt_Device("!") == 0) {
283 gui_msg("decrypt_success=Successfully decrypted with default password.");
284 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
285 } else {
286 gui_err("unable_to_decrypt=Unable to decrypt with default password.");
287 }
Ethan Yonkercceebb82014-11-18 10:17:59 -0600288 }
289 } else {
Ethan Yonkerbd7492d2016-12-07 13:55:01 -0600290 int password_type = cryptfs_get_password_type();
291 if (password_type == CRYPT_TYPE_DEFAULT) {
292 LOGINFO("Device is encrypted with the default password, attempting to decrypt.\n");
293 if (Decrypt_Device("default_password") == 0) {
294 gui_msg("decrypt_success=Successfully decrypted with default password.");
295 DataManager::SetValue(TW_IS_ENCRYPTED, 0);
296 } else {
297 gui_err("unable_to_decrypt=Unable to decrypt with default password.");
298 }
299 } else {
300 DataManager::SetValue("TW_CRYPTO_TYPE", password_type);
301 }
Ethan Yonkercceebb82014-11-18 10:17:59 -0600302 }
303 }
Ethan Yonker66a19492015-12-10 10:19:45 -0600304 if (Decrypt_Data && (!Decrypt_Data->Is_Encrypted || Decrypt_Data->Is_Decrypted) && Decrypt_Data->Mount(false)) {
305 Decrypt_Adopted();
306 }
Ethan Yonkercceebb82014-11-18 10:17:59 -0600307#endif
Dees_Troy51127312012-09-08 13:08:49 -0400308 Update_System_Details();
Dees_Troyd0384ef2012-10-12 12:15:42 -0400309 UnMount_Main_Partitions();
Ethan Yonker1b190162016-12-05 15:25:19 -0600310#ifdef AB_OTA_UPDATER
311 DataManager::SetValue("tw_active_slot", Get_Active_Slot_Display());
312#endif
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600313 setup_uevent();
Dees_Troy5bf43922012-09-07 16:07:55 -0400314 return true;
315}
316
317int TWPartitionManager::Write_Fstab(void) {
318 FILE *fp;
319 std::vector<TWPartition*>::iterator iter;
320 string Line;
321
322 fp = fopen("/etc/fstab", "w");
323 if (fp == NULL) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000324 LOGINFO("Can not open /etc/fstab.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -0400325 return false;
326 }
Dees_Troy63c8df72012-09-10 14:02:05 -0400327 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy51127312012-09-08 13:08:49 -0400328 if ((*iter)->Can_Be_Mounted) {
dianlujitao7d304c72016-01-02 12:15:50 +0800329 Line = (*iter)->Actual_Block_Device + " " + (*iter)->Mount_Point + " " + (*iter)->Current_File_System + " rw 0 0\n";
Dees_Troy5bf43922012-09-07 16:07:55 -0400330 fputs(Line.c_str(), fp);
Dees_Troy91862e62013-04-04 23:48:21 +0000331 }
332 // Handle subpartition tracking
333 if ((*iter)->Is_SubPartition) {
334 TWPartition* ParentPartition = Find_Partition_By_Path((*iter)->SubPartition_Of);
335 if (ParentPartition)
336 ParentPartition->Has_SubPartition = true;
337 else
338 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 -0400339 }
340 }
341 fclose(fp);
342 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400343}
344
Ethan Yonkerc05c5982014-03-13 09:19:56 -0500345void TWPartitionManager::Setup_Settings_Storage_Partition(TWPartition* Part) {
Ethan Yonkerc05c5982014-03-13 09:19:56 -0500346 DataManager::SetValue("tw_settings_path", Part->Storage_Path);
347 DataManager::SetValue("tw_storage_path", Part->Storage_Path);
348 LOGINFO("Settings storage is '%s'\n", Part->Storage_Path.c_str());
349}
350
Matt Mowerbf4efa32014-04-14 23:25:26 -0500351void TWPartitionManager::Setup_Android_Secure_Location(TWPartition* Part) {
352 if (Part->Has_Android_Secure)
353 Part->Setup_AndSec();
Ethan Yonker6277c792014-09-15 14:54:30 -0500354 else if (!datamedia)
Matt Mowerbf4efa32014-04-14 23:25:26 -0500355 Part->Setup_AndSec();
Matt Mowerbf4efa32014-04-14 23:25:26 -0500356}
357
Dees_Troy8170a922012-09-18 15:40:25 -0400358void TWPartitionManager::Output_Partition_Logging(void) {
359 std::vector<TWPartition*>::iterator iter;
360
361 printf("\n\nPartition Logs:\n");
362 for (iter = Partitions.begin(); iter != Partitions.end(); iter++)
363 Output_Partition((*iter));
364}
365
366void TWPartitionManager::Output_Partition(TWPartition* Part) {
367 unsigned long long mb = 1048576;
368
Gary Peck004d48b2012-11-21 16:28:18 -0800369 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 -0400370 if (Part->Can_Be_Mounted) {
Gary Peck004d48b2012-11-21 16:28:18 -0800371 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 -0400372 }
Gary Peck004d48b2012-11-21 16:28:18 -0800373 printf("\n Flags: ");
Dees_Troya13d74f2013-03-24 08:54:55 -0500374 if (Part->Can_Be_Mounted)
375 printf("Can_Be_Mounted ");
Gary Peck004d48b2012-11-21 16:28:18 -0800376 if (Part->Can_Be_Wiped)
377 printf("Can_Be_Wiped ");
Hashcodedabfd492013-08-29 22:45:30 -0700378 if (Part->Use_Rm_Rf)
379 printf("Use_Rm_Rf ");
Dees_Troya13d74f2013-03-24 08:54:55 -0500380 if (Part->Can_Be_Backed_Up)
381 printf("Can_Be_Backed_Up ");
Gary Peck004d48b2012-11-21 16:28:18 -0800382 if (Part->Wipe_During_Factory_Reset)
383 printf("Wipe_During_Factory_Reset ");
384 if (Part->Wipe_Available_in_GUI)
385 printf("Wipe_Available_in_GUI ");
386 if (Part->Is_SubPartition)
387 printf("Is_SubPartition ");
388 if (Part->Has_SubPartition)
389 printf("Has_SubPartition ");
390 if (Part->Removable)
391 printf("Removable ");
392 if (Part->Is_Present)
393 printf("IsPresent ");
394 if (Part->Can_Be_Encrypted)
395 printf("Can_Be_Encrypted ");
396 if (Part->Is_Encrypted)
397 printf("Is_Encrypted ");
398 if (Part->Is_Decrypted)
399 printf("Is_Decrypted ");
400 if (Part->Has_Data_Media)
401 printf("Has_Data_Media ");
Dees_Troy83bd4832013-05-04 12:39:56 +0000402 if (Part->Can_Encrypt_Backup)
403 printf("Can_Encrypt_Backup ");
404 if (Part->Use_Userdata_Encryption)
405 printf("Use_Userdata_Encryption ");
Gary Peck004d48b2012-11-21 16:28:18 -0800406 if (Part->Has_Android_Secure)
407 printf("Has_Android_Secure ");
408 if (Part->Is_Storage)
409 printf("Is_Storage ");
Dees_Troya13d74f2013-03-24 08:54:55 -0500410 if (Part->Is_Settings_Storage)
411 printf("Is_Settings_Storage ");
Dees_Troy68cab492012-12-12 19:29:35 +0000412 if (Part->Ignore_Blkid)
413 printf("Ignore_Blkid ");
Dees_Troy16c2b312013-01-15 16:51:18 +0000414 if (Part->Retain_Layout_Version)
415 printf("Retain_Layout_Version ");
Ethan Yonker253368a2014-11-25 15:00:52 -0600416 if (Part->Mount_To_Decrypt)
417 printf("Mount_To_Decrypt ");
Ethan Yonker96af84a2015-01-05 14:58:36 -0600418 if (Part->Can_Flash_Img)
419 printf("Can_Flash_Img ");
Ethan Yonker66a19492015-12-10 10:19:45 -0600420 if (Part->Is_Adopted_Storage)
421 printf("Is_Adopted_Storage ");
Ethan Yonker1b190162016-12-05 15:25:19 -0600422 if (Part->SlotSelect)
423 printf("SlotSelect ");
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600424 if (Part->Mount_Read_Only)
425 printf("Mount_Read_Only ");
Gary Peck004d48b2012-11-21 16:28:18 -0800426 printf("\n");
427 if (!Part->SubPartition_Of.empty())
428 printf(" SubPartition_Of: %s\n", Part->SubPartition_Of.c_str());
429 if (!Part->Symlink_Path.empty())
430 printf(" Symlink_Path: %s\n", Part->Symlink_Path.c_str());
431 if (!Part->Symlink_Mount_Point.empty())
432 printf(" Symlink_Mount_Point: %s\n", Part->Symlink_Mount_Point.c_str());
433 if (!Part->Primary_Block_Device.empty())
434 printf(" Primary_Block_Device: %s\n", Part->Primary_Block_Device.c_str());
435 if (!Part->Alternate_Block_Device.empty())
436 printf(" Alternate_Block_Device: %s\n", Part->Alternate_Block_Device.c_str());
437 if (!Part->Decrypted_Block_Device.empty())
438 printf(" Decrypted_Block_Device: %s\n", Part->Decrypted_Block_Device.c_str());
Ethan Yonker253368a2014-11-25 15:00:52 -0600439 if (!Part->Crypto_Key_Location.empty() && Part->Crypto_Key_Location != "footer")
440 printf(" Crypto_Key_Location: %s\n", Part->Crypto_Key_Location.c_str());
Gary Peck004d48b2012-11-21 16:28:18 -0800441 if (Part->Length != 0)
442 printf(" Length: %i\n", Part->Length);
443 if (!Part->Display_Name.empty())
444 printf(" Display_Name: %s\n", Part->Display_Name.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500445 if (!Part->Storage_Name.empty())
446 printf(" Storage_Name: %s\n", Part->Storage_Name.c_str());
Gary Peck004d48b2012-11-21 16:28:18 -0800447 if (!Part->Backup_Path.empty())
448 printf(" Backup_Path: %s\n", Part->Backup_Path.c_str());
449 if (!Part->Backup_Name.empty())
450 printf(" Backup_Name: %s\n", Part->Backup_Name.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500451 if (!Part->Backup_Display_Name.empty())
452 printf(" Backup_Display_Name: %s\n", Part->Backup_Display_Name.c_str());
Gary Peck004d48b2012-11-21 16:28:18 -0800453 if (!Part->Backup_FileName.empty())
454 printf(" Backup_FileName: %s\n", Part->Backup_FileName.c_str());
455 if (!Part->Storage_Path.empty())
456 printf(" Storage_Path: %s\n", Part->Storage_Path.c_str());
457 if (!Part->Current_File_System.empty())
458 printf(" Current_File_System: %s\n", Part->Current_File_System.c_str());
459 if (!Part->Fstab_File_System.empty())
460 printf(" Fstab_File_System: %s\n", Part->Fstab_File_System.c_str());
461 if (Part->Format_Block_Size != 0)
Ethan Yonkerc798c9c2015-10-09 11:15:26 -0500462 printf(" Format_Block_Size: %lu\n", Part->Format_Block_Size);
Dees_Troy094207a2012-09-26 12:00:39 -0400463 if (!Part->MTD_Name.empty())
464 printf(" MTD_Name: %s\n", Part->MTD_Name.c_str());
Matt Mower029a82d2017-01-08 13:12:38 -0600465 printf(" Backup_Method: %s\n", Part->Backup_Method_By_Name().c_str());
Hashcode62bd9e02013-11-19 21:59:42 -0800466 if (Part->Mount_Flags || !Part->Mount_Options.empty())
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600467 printf(" Mount_Flags: %i, Mount_Options: %s\n", Part->Mount_Flags, Part->Mount_Options.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -0600468 if (Part->MTP_Storage_ID)
469 printf(" MTP_Storage_ID: %i\n", Part->MTP_Storage_ID);
Ethan Yonker6277c792014-09-15 14:54:30 -0500470 printf("\n");
Dees_Troy8170a922012-09-18 15:40:25 -0400471}
472
Dees_Troy51a0e822012-09-05 15:24:24 -0400473int TWPartitionManager::Mount_By_Path(string Path, bool Display_Error) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400474 std::vector<TWPartition*>::iterator iter;
475 int ret = false;
476 bool found = false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400477 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy5bf43922012-09-07 16:07:55 -0400478
Dees_Troyd93bda52013-07-03 19:55:19 +0000479 if (Local_Path == "/tmp" || Local_Path == "/")
Dees_Troy43d8b002012-09-17 16:00:01 -0400480 return true;
481
Dees_Troy5bf43922012-09-07 16:07:55 -0400482 // Iterate through all partitions
483 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -0400484 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400485 ret = (*iter)->Mount(Display_Error);
486 found = true;
Dees_Troy51127312012-09-08 13:08:49 -0400487 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400488 (*iter)->Mount(Display_Error);
Dees_Troy51127312012-09-08 13:08:49 -0400489 }
Dees_Troy5bf43922012-09-07 16:07:55 -0400490 }
491 if (found) {
492 return ret;
493 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500494 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 -0400495 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000496 LOGINFO("Mount: Unable to find partition for path '%s'\n", Local_Path.c_str());
Dees_Troy5bf43922012-09-07 16:07:55 -0400497 }
498 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400499}
500
Dees_Troy51a0e822012-09-05 15:24:24 -0400501int TWPartitionManager::UnMount_By_Path(string Path, bool Display_Error) {
Dees_Troy51127312012-09-08 13:08:49 -0400502 std::vector<TWPartition*>::iterator iter;
503 int ret = false;
504 bool found = false;
Dees_Troy38bd7602012-09-14 13:33:53 -0400505 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy51127312012-09-08 13:08:49 -0400506
507 // Iterate through all partitions
508 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -0400509 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
Dees_Troy51127312012-09-08 13:08:49 -0400510 ret = (*iter)->UnMount(Display_Error);
511 found = true;
512 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
513 (*iter)->UnMount(Display_Error);
514 }
515 }
516 if (found) {
517 return ret;
518 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500519 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 -0400520 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000521 LOGINFO("UnMount: Unable to find partition for path '%s'\n", Local_Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400522 }
523 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400524}
525
Dees_Troy51a0e822012-09-05 15:24:24 -0400526int TWPartitionManager::Is_Mounted_By_Path(string Path) {
Dees_Troy51127312012-09-08 13:08:49 -0400527 TWPartition* Part = Find_Partition_By_Path(Path);
528
529 if (Part)
530 return Part->Is_Mounted();
531 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000532 LOGINFO("Is_Mounted: Unable to find partition for path '%s'\n", Path.c_str());
Dees_Troy51127312012-09-08 13:08:49 -0400533 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400534}
535
Dees_Troy5bf43922012-09-07 16:07:55 -0400536int TWPartitionManager::Mount_Current_Storage(bool Display_Error) {
Dees_Troy51127312012-09-08 13:08:49 -0400537 string current_storage_path = DataManager::GetCurrentStoragePath();
538
539 if (Mount_By_Path(current_storage_path, Display_Error)) {
540 TWPartition* FreeStorage = Find_Partition_By_Path(current_storage_path);
541 if (FreeStorage)
542 DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)(FreeStorage->Free / 1048576LLU));
543 return true;
544 }
545 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -0400546}
547
Dees_Troy5bf43922012-09-07 16:07:55 -0400548int TWPartitionManager::Mount_Settings_Storage(bool Display_Error) {
549 return Mount_By_Path(DataManager::GetSettingsStoragePath(), Display_Error);
550}
551
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600552TWPartition* TWPartitionManager::Find_Partition_By_Path(const string& Path) {
Dees_Troy5bf43922012-09-07 16:07:55 -0400553 std::vector<TWPartition*>::iterator iter;
Dees_Troy38bd7602012-09-14 13:33:53 -0400554 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy5bf43922012-09-07 16:07:55 -0400555
556 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -0400557 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path))
Dees_Troy5bf43922012-09-07 16:07:55 -0400558 return (*iter);
559 }
Dees_Troy51a0e822012-09-05 15:24:24 -0400560 return NULL;
561}
562
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600563TWPartition* TWPartitionManager::Find_Partition_By_Block_Device(const string& Block_Device) {
564 std::vector<TWPartition*>::iterator iter;
565
566 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
567 if ((*iter)->Primary_Block_Device == Block_Device || (!(*iter)->Actual_Block_Device.empty() && (*iter)->Actual_Block_Device == Block_Device))
568 return (*iter);
569 }
570 return NULL;
571}
572
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400573int TWPartitionManager::Check_Backup_Name(bool Display_Error) {
574 // Check the backup name to ensure that it is the correct size and contains only valid characters
575 // and that a backup with that name doesn't already exist
576 char backup_name[MAX_BACKUP_NAME_LEN];
577 char backup_loc[255], tw_image_dir[255];
578 int copy_size;
579 int index, cur_char;
580 string Backup_Name, Backup_Loc;
581
582 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
583 copy_size = Backup_Name.size();
584 // Check size
585 if (copy_size > MAX_BACKUP_NAME_LEN) {
586 if (Display_Error)
Ethan Yonker74db1572015-10-28 12:44:49 -0500587 gui_err("backup_name_len=Backup name is too long.");
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400588 return -2;
589 }
590
591 // Check each character
592 strncpy(backup_name, Backup_Name.c_str(), copy_size);
Dees_Troya13d74f2013-03-24 08:54:55 -0500593 if (copy_size == 1 && strncmp(backup_name, "0", 1) == 0)
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400594 return 0; // A "0" (zero) means to use the current timestamp for the backup name
595 for (index=0; index<copy_size; index++) {
596 cur_char = (int)backup_name[index];
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500597 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 -0400598 // These are valid characters
599 // Numbers
600 // Upper case letters
601 // Lower case letters
602 // Space
603 // and -_.{}[]
604 } else {
605 if (Display_Error)
Ethan Yonker4adc33e2016-01-22 16:07:11 -0600606 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 -0400607 return -3;
608 }
609 }
610
611 // Check to make sure that a backup with this name doesn't already exist
612 DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, Backup_Loc);
613 strcpy(backup_loc, Backup_Loc.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -0500614 sprintf(tw_image_dir,"%s/%s", backup_loc, Backup_Name.c_str());
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500615 if (TWFunc::Path_Exists(tw_image_dir)) {
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400616 if (Display_Error)
Matt Mower3c366972015-12-25 19:28:31 -0600617 gui_err("backup_name_exists=A backup with that name already exists!");
bigbiffce8f83c2015-12-12 18:30:21 -0500618
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400619 return -4;
620 }
Dees_Troyc9ff7a32012-09-27 10:09:41 -0400621 // No problems found, return 0
622 return 0;
623}
624
bigbiffce8f83c2015-12-12 18:30:21 -0500625bool TWPartitionManager::Backup_Partition(PartitionSettings *part_settings) {
Dees_Troy43d8b002012-09-17 16:00:01 -0400626 time_t start, stop;
Matt Mower23d8aae2017-01-06 14:30:33 -0600627 int use_compression;
bigbiffce8f83c2015-12-12 18:30:21 -0500628 string backup_log = part_settings->Backup_Folder + "/recovery.log";
Dees_Troy43d8b002012-09-17 16:00:01 -0400629
bigbiffce8f83c2015-12-12 18:30:21 -0500630 if (part_settings->Part == NULL)
Dees_Troy43d8b002012-09-17 16:00:01 -0400631 return true;
632
Dees_Troy093b7642012-09-21 15:59:38 -0400633 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy093b7642012-09-21 15:59:38 -0400634
Tom Hite5a926722014-09-15 01:31:03 +0000635 TWFunc::SetPerformanceMode(true);
Dees_Troy43d8b002012-09-17 16:00:01 -0400636 time(&start);
637
bigbiffce8f83c2015-12-12 18:30:21 -0500638 if (part_settings->Part->Backup(part_settings, &tar_fork_pid)) {
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500639 sync();
640 sync();
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400641 string Full_Filename = part_settings->Backup_Folder + "/" + part_settings->Part->Backup_FileName;
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500642 if (!part_settings->adbbackup && part_settings->generate_digest) {
643 if (!twrpDigestDriver::Make_Digest(Full_Filename))
644 goto backup_error;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400645 }
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400646
bigbiffce8f83c2015-12-12 18:30:21 -0500647 if (part_settings->Part->Has_SubPartition) {
Dees_Troy8170a922012-09-18 15:40:25 -0400648 std::vector<TWPartition*>::iterator subpart;
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400649 TWPartition *parentPart = part_settings->Part;
Dees_Troy8170a922012-09-18 15:40:25 -0400650
651 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400652 if ((*subpart)->Can_Be_Backed_Up && (*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) {
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500653 part_settings->Part = *subpart;
bigbiffce8f83c2015-12-12 18:30:21 -0500654 if (!(*subpart)->Backup(part_settings, &tar_fork_pid)) {
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500655 goto backup_error;
Tom Hite5a926722014-09-15 01:31:03 +0000656 }
Dees_Troy2727b992013-08-14 20:09:30 +0000657 sync();
658 sync();
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400659 if (!part_settings->adbbackup && part_settings->generate_digest) {
660 if (!twrpDigestDriver::Make_Digest(Full_Filename)) {
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500661 goto backup_error;
bigbiffce8f83c2015-12-12 18:30:21 -0500662 }
Tom Hite5a926722014-09-15 01:31:03 +0000663 }
Dees_Troy8170a922012-09-18 15:40:25 -0400664 }
665 }
666 }
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400667
Dees_Troy43d8b002012-09-17 16:00:01 -0400668 time(&stop);
that203bcc92015-05-09 17:27:33 +0200669 int backup_time = (int) difftime(stop, start);
Dees_Troy2673cec2013-04-02 20:22:16 +0000670 LOGINFO("Partition Backup time: %d\n", backup_time);
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400671
bigbiffce8f83c2015-12-12 18:30:21 -0500672 if (part_settings->Part->Backup_Method == BM_FILES) {
673 part_settings->file_time += backup_time;
Dees_Troy43d8b002012-09-17 16:00:01 -0400674 } else {
bigbiffce8f83c2015-12-12 18:30:21 -0500675 part_settings->img_time += backup_time;
676
Dees_Troy43d8b002012-09-17 16:00:01 -0400677 }
Tom Hite5a926722014-09-15 01:31:03 +0000678
Matt Mower02899552016-12-30 18:13:51 -0600679 TWFunc::SetPerformanceMode(false);
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500680 return true;
Dees_Troy43d8b002012-09-17 16:00:01 -0400681 }
Ethan Yonkercd00a8b2017-07-06 10:23:30 -0500682backup_error:
683 Clean_Backup_Folder(part_settings->Backup_Folder);
684 TWFunc::copy_file("/tmp/recovery.log", backup_log, 0644);
685 tw_set_default_metadata(backup_log.c_str());
686 TWFunc::SetPerformanceMode(false);
687 return false;
bigbiff7abc5fe2015-01-17 16:53:12 -0500688}
689
bigbiffbf1d6722015-02-14 16:25:59 -0500690void TWPartitionManager::Clean_Backup_Folder(string Backup_Folder) {
691 DIR *d = opendir(Backup_Folder.c_str());
692 struct dirent *p;
693 int r;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400694 vector<string> ext;
695
696 //extensions we should delete when cleaning
697 ext.push_back("win");
698 ext.push_back("md5");
699 ext.push_back("sha2");
700 ext.push_back("info");
bigbiffbf1d6722015-02-14 16:25:59 -0500701
Ethan Yonker74db1572015-10-28 12:44:49 -0500702 gui_msg("backup_clean=Backup Failed. Cleaning Backup Folder.");
bigbiffbf1d6722015-02-14 16:25:59 -0500703
704 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500705 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Backup_Folder)(strerror(errno)));
bigbiffbf1d6722015-02-14 16:25:59 -0500706 return;
707 }
708
Matt Mower2b18a532015-02-20 16:58:05 -0600709 while ((p = readdir(d))) {
bigbiffbf1d6722015-02-14 16:25:59 -0500710 if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
711 continue;
712
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500713 string path = Backup_Folder + "/" + p->d_name;
bigbiffbf1d6722015-02-14 16:25:59 -0500714
715 size_t dot = path.find_last_of(".") + 1;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400716 for (vector<string>::const_iterator i = ext.begin(); i != ext.end(); ++i) {
717 if (path.substr(dot) == *i) {
718 r = unlink(path.c_str());
719 if (r != 0)
720 LOGINFO("Unable to unlink '%s: %s'\n", path.c_str(), strerror(errno));
bigbiffbf1d6722015-02-14 16:25:59 -0500721 }
722 }
723 }
724 closedir(d);
725}
726
Ethan Yonker472f5062016-02-25 13:47:30 -0600727int TWPartitionManager::Check_Backup_Cancel() {
728 return stop_backup.get_value();
729}
730
bigbiff7abc5fe2015-01-17 16:53:12 -0500731int TWPartitionManager::Cancel_Backup() {
732 string Backup_Folder, Backup_Name, Full_Backup_Path;
733
734 stop_backup.set_value(1);
735
736 if (tar_fork_pid != 0) {
737 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
738 DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, Backup_Folder);
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500739 Full_Backup_Path = Backup_Folder + "/" + Backup_Name;
bigbiff7abc5fe2015-01-17 16:53:12 -0500740 LOGINFO("Killing pid: %d\n", tar_fork_pid);
741 kill(tar_fork_pid, SIGUSR2);
742 while (kill(tar_fork_pid, 0) == 0) {
743 usleep(1000);
744 }
745 LOGINFO("Backup_Run stopped and returning false, backup cancelled.\n");
746 LOGINFO("Removing directory %s\n", Full_Backup_Path.c_str());
747 TWFunc::removeDir(Full_Backup_Path, false);
748 tar_fork_pid = 0;
749 }
750
751 return 0;
Dees_Troy43d8b002012-09-17 16:00:01 -0400752}
753
bigbiffce8f83c2015-12-12 18:30:21 -0500754int TWPartitionManager::Run_Backup(bool adbbackup) {
755 PartitionSettings part_settings;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400756 int partition_count = 0, disable_free_space_check = 0, skip_digest = 0;
bigbiffce8f83c2015-12-12 18:30:21 -0500757 string Backup_Name, Backup_List, backup_path;
Matt Mower23d8aae2017-01-06 14:30:33 -0600758 unsigned long long total_bytes = 0, free_space = 0;
Dees_Troy43d8b002012-09-17 16:00:01 -0400759 TWPartition* storage = NULL;
Dees_Troy8170a922012-09-18 15:40:25 -0400760 std::vector<TWPartition*>::iterator subpart;
Dees_Troy43d8b002012-09-17 16:00:01 -0400761 struct tm *t;
Matt Mower23d8aae2017-01-06 14:30:33 -0600762 time_t seconds, total_start, total_stop;
Dees_Troya13d74f2013-03-24 08:54:55 -0500763 size_t start_pos = 0, end_pos = 0;
bigbiff7abc5fe2015-01-17 16:53:12 -0500764 stop_backup.set_value(0);
Dees_Troy43d8b002012-09-17 16:00:01 -0400765 seconds = time(0);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500766 t = localtime(&seconds);
Dees_Troy43d8b002012-09-17 16:00:01 -0400767
bigbiffce8f83c2015-12-12 18:30:21 -0500768 part_settings.img_bytes_remaining = 0;
769 part_settings.file_bytes_remaining = 0;
770 part_settings.img_time = 0;
771 part_settings.file_time = 0;
772 part_settings.img_bytes = 0;
773 part_settings.file_bytes = 0;
774 part_settings.PM_Method = PM_BACKUP;
775
bigbiffce8f83c2015-12-12 18:30:21 -0500776 part_settings.adbbackup = adbbackup;
Dees_Troy43d8b002012-09-17 16:00:01 -0400777 time(&total_start);
778
779 Update_System_Details();
780
781 if (!Mount_Current_Storage(true))
782 return false;
783
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400784 DataManager::GetValue(TW_SKIP_DIGEST_GENERATE_VAR, skip_digest);
785 if (skip_digest == 0)
786 part_settings.generate_digest = true;
Dees_Troyc5865ab2012-09-24 15:08:04 -0400787 else
bigbiff bigbiff56cf5642016-08-19 17:43:45 -0400788 part_settings.generate_digest = false;
Dees_Troy4a2a1262012-09-18 09:33:47 -0400789
bigbiffce8f83c2015-12-12 18:30:21 -0500790 DataManager::GetValue(TW_BACKUPS_FOLDER_VAR, part_settings.Backup_Folder);
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500791 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
792 if (Backup_Name == gui_lookup("curr_date", "(Current Date)")) {
793 Backup_Name = TWFunc::Get_Current_Date();
794 } else if (Backup_Name == gui_lookup("auto_generate", "(Auto Generate)") || Backup_Name == "0" || Backup_Name.empty()) {
Dees Troyb21cc642013-09-10 17:36:41 +0000795 TWFunc::Auto_Generate_Backup_Name();
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500796 DataManager::GetValue(TW_BACKUP_NAME, Backup_Name);
Dees_Troy43d8b002012-09-17 16:00:01 -0400797 }
bigbiffce8f83c2015-12-12 18:30:21 -0500798
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500799 LOGINFO("Backup Name is: '%s'\n", Backup_Name.c_str());
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500800 part_settings.Backup_Folder = part_settings.Backup_Folder + "/" + Backup_Name;
bigbiffce8f83c2015-12-12 18:30:21 -0500801
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500802 LOGINFO("Backup_Folder is: '%s'\n", part_settings.Backup_Folder.c_str());
Dees_Troy43d8b002012-09-17 16:00:01 -0400803
Dees_Troy2673cec2013-04-02 20:22:16 +0000804 LOGINFO("Calculating backup details...\n");
Dees_Troya13d74f2013-03-24 08:54:55 -0500805 DataManager::GetValue("tw_backup_list", Backup_List);
806 if (!Backup_List.empty()) {
807 end_pos = Backup_List.find(";", start_pos);
808 while (end_pos != string::npos && start_pos < Backup_List.size()) {
809 backup_path = Backup_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -0500810 part_settings.Part = Find_Partition_By_Path(backup_path);
811 if (part_settings.Part != NULL) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500812 partition_count++;
bigbiffce8f83c2015-12-12 18:30:21 -0500813 if (part_settings.Part->Backup_Method == BM_FILES)
814 part_settings.file_bytes += part_settings.Part->Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -0500815 else
bigbiffce8f83c2015-12-12 18:30:21 -0500816 part_settings.img_bytes += part_settings.Part->Backup_Size;
817 if (part_settings.Part->Has_SubPartition) {
Dees_Troya13d74f2013-03-24 08:54:55 -0500818 std::vector<TWPartition*>::iterator subpart;
819
820 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiffce8f83c2015-12-12 18:30:21 -0500821 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 -0500822 partition_count++;
bigbiffce8f83c2015-12-12 18:30:21 -0500823 if ((*subpart)->Backup_Method == BM_FILES)
824 part_settings.file_bytes += (*subpart)->Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -0500825 else
bigbiffce8f83c2015-12-12 18:30:21 -0500826 part_settings.img_bytes += (*subpart)->Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -0500827 }
828 }
Dees_Troy8170a922012-09-18 15:40:25 -0400829 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500830 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500831 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 -0400832 }
Dees_Troya13d74f2013-03-24 08:54:55 -0500833 start_pos = end_pos + 1;
834 end_pos = Backup_List.find(";", start_pos);
Dees_Troy43d8b002012-09-17 16:00:01 -0400835 }
836 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400837
838 if (partition_count == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500839 gui_msg("no_partition_selected=No partitions selected for backup.");
Dees_Troy43d8b002012-09-17 16:00:01 -0400840 return false;
841 }
bigbiffce8f83c2015-12-12 18:30:21 -0500842 if (adbbackup) {
843 if (twadbbu::Write_ADB_Stream_Header(partition_count) == false) {
844 return false;
845 }
846 }
847 total_bytes = part_settings.file_bytes + part_settings.img_bytes;
Ethan Yonker472f5062016-02-25 13:47:30 -0600848 ProgressTracking progress(total_bytes);
bigbiffce8f83c2015-12-12 18:30:21 -0500849 part_settings.progress = &progress;
850
Ethan Yonker74db1572015-10-28 12:44:49 -0500851 gui_msg(Msg("total_partitions_backup= * Total number of partitions to back up: {1}")(partition_count));
852 gui_msg(Msg("total_backup_size= * Total size of all data: {1}MB")(total_bytes / 1024 / 1024));
Dees_Troy43d8b002012-09-17 16:00:01 -0400853 storage = Find_Partition_By_Path(DataManager::GetCurrentStoragePath());
854 if (storage != NULL) {
855 free_space = storage->Free;
Ethan Yonker74db1572015-10-28 12:44:49 -0500856 gui_msg(Msg("available_space= * Available space: {1}MB")(free_space / 1024 / 1024));
Dees_Troy43d8b002012-09-17 16:00:01 -0400857 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500858 gui_err("unable_locate_storage=Unable to locate storage device.");
Dees_Troy43d8b002012-09-17 16:00:01 -0400859 return false;
860 }
bigbiffbf1d6722015-02-14 16:25:59 -0500861
Matt Mowerbfccfb82016-04-25 23:22:31 -0500862 DataManager::GetValue(TW_DISABLE_FREE_SPACE_VAR, disable_free_space_check);
bigbiffce8f83c2015-12-12 18:30:21 -0500863
864 if (adbbackup)
865 disable_free_space_check = true;
866
bigbiffbf1d6722015-02-14 16:25:59 -0500867 if (!disable_free_space_check) {
868 if (free_space - (32 * 1024 * 1024) < total_bytes) {
869 // We require an extra 32MB just in case
Ethan Yonker74db1572015-10-28 12:44:49 -0500870 gui_err("no_space=Not enough free space on storage.");
bigbiffbf1d6722015-02-14 16:25:59 -0500871 return false;
872 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400873 }
bigbiffce8f83c2015-12-12 18:30:21 -0500874 part_settings.img_bytes_remaining = part_settings.img_bytes;
875 part_settings.file_bytes_remaining = part_settings.file_bytes;
Dees_Troy43d8b002012-09-17 16:00:01 -0400876
Ethan Yonker74db1572015-10-28 12:44:49 -0500877 gui_msg("backup_started=[BACKUP STARTED]");
Ethan Yonkerdcf2b672016-09-13 14:41:53 -0500878 gui_msg(Msg("backup_folder= * Backup Folder: {1}")(part_settings.Backup_Folder));
879 if (!TWFunc::Recursive_Mkdir(part_settings.Backup_Folder)) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500880 gui_err("fail_backup_folder=Failed to make backup folder.");
Dees_Troyd4b22b02013-01-18 17:17:58 +0000881 return false;
882 }
883
Dees_Troy2673cec2013-04-02 20:22:16 +0000884 DataManager::SetProgress(0.0);
Dees_Troy093b7642012-09-21 15:59:38 -0400885
Dees_Troya13d74f2013-03-24 08:54:55 -0500886 start_pos = 0;
887 end_pos = Backup_List.find(";", start_pos);
888 while (end_pos != string::npos && start_pos < Backup_List.size()) {
bigbiff7abc5fe2015-01-17 16:53:12 -0500889 if (stop_backup.get_value() != 0)
890 return -1;
Dees_Troya13d74f2013-03-24 08:54:55 -0500891 backup_path = Backup_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -0500892 part_settings.Part = Find_Partition_By_Path(backup_path);
893 if (part_settings.Part != NULL) {
894 if (!Backup_Partition(&part_settings))
Dees_Troya13d74f2013-03-24 08:54:55 -0500895 return false;
896 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500897 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 -0500898 }
899 start_pos = end_pos + 1;
900 end_pos = Backup_List.find(";", start_pos);
901 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400902
903 // Average BPS
bigbiffce8f83c2015-12-12 18:30:21 -0500904 if (part_settings.img_time == 0)
905 part_settings.img_time = 1;
906 if (part_settings.file_time == 0)
907 part_settings.file_time = 1;
908 int img_bps = (int)part_settings.img_bytes / (int)part_settings.img_time;
909 unsigned long long file_bps = part_settings.file_bytes / (int)part_settings.file_time;
Dees_Troy43d8b002012-09-17 16:00:01 -0400910
bigbiffce8f83c2015-12-12 18:30:21 -0500911 if (part_settings.file_bytes != 0)
Ethan Yonker472f5062016-02-25 13:47:30 -0600912 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 -0500913 if (part_settings.img_bytes != 0)
Ethan Yonker472f5062016-02-25 13:47:30 -0600914 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 -0400915
916 time(&total_stop);
917 int total_time = (int) difftime(total_stop, total_start);
bigbiffce8f83c2015-12-12 18:30:21 -0500918
919 uint64_t actual_backup_size;
Ethan Yonker3fdcda42016-11-30 12:29:37 -0600920 if (!adbbackup) {
921 TWExclude twe;
922 actual_backup_size = twe.Get_Folder_Size(part_settings.Backup_Folder);
923 } else
bigbiffce8f83c2015-12-12 18:30:21 -0500924 actual_backup_size = part_settings.file_bytes + part_settings.img_bytes;
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500925 actual_backup_size /= (1024LLU * 1024LLU);
Dees_Troy43d8b002012-09-17 16:00:01 -0400926
bigbiffce8f83c2015-12-12 18:30:21 -0500927 int prev_img_bps = 0, use_compression = 0;
928 unsigned long long prev_file_bps = 0;
Matt Mower173cdb92016-12-31 02:49:19 -0600929 DataManager::GetValue(TW_BACKUP_AVG_IMG_RATE, prev_img_bps);
Dees_Troy093b7642012-09-21 15:59:38 -0400930 img_bps += (prev_img_bps * 4);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500931 img_bps /= 5;
Dees_Troy093b7642012-09-21 15:59:38 -0400932
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500933 DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression);
Dees_Troy093b7642012-09-21 15:59:38 -0400934 if (use_compression)
935 DataManager::GetValue(TW_BACKUP_AVG_FILE_COMP_RATE, prev_file_bps);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500936 else
Dees_Troy093b7642012-09-21 15:59:38 -0400937 DataManager::GetValue(TW_BACKUP_AVG_FILE_RATE, prev_file_bps);
938 file_bps += (prev_file_bps * 4);
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500939 file_bps /= 5;
Dees_Troy093b7642012-09-21 15:59:38 -0400940
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500941 DataManager::SetValue(TW_BACKUP_AVG_IMG_RATE, img_bps);
Dees_Troy093b7642012-09-21 15:59:38 -0400942 if (use_compression)
943 DataManager::SetValue(TW_BACKUP_AVG_FILE_COMP_RATE, file_bps);
944 else
945 DataManager::SetValue(TW_BACKUP_AVG_FILE_RATE, file_bps);
946
Ethan Yonker74db1572015-10-28 12:44:49 -0500947 gui_msg(Msg("total_backed_size=[{1} MB TOTAL BACKED UP]")(actual_backup_size));
Dees_Troy43d8b002012-09-17 16:00:01 -0400948 Update_System_Details();
Dees_Troyd0384ef2012-10-12 12:15:42 -0400949 UnMount_Main_Partitions();
Ethan Yonker56db1c42015-12-20 22:49:00 -0600950 gui_msg(Msg(msg::kHighlight, "backup_completed=[BACKUP COMPLETED IN {1} SECONDS]")(total_time)); // the end
Ethan Yonkere080c1f2016-09-19 13:50:25 -0500951 string backup_log = part_settings.Backup_Folder + "/recovery.log";
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000952 TWFunc::copy_file("/tmp/recovery.log", backup_log, 0644);
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600953 tw_set_default_metadata(backup_log.c_str());
bigbiffce8f83c2015-12-12 18:30:21 -0500954
955 if (part_settings.adbbackup) {
956 if (twadbbu::Write_ADB_Stream_Trailer() == false) {
957 return false;
958 }
959 }
960 part_settings.adbbackup = false;
961 DataManager::SetValue("tw_enable_adb_backup", 0);
962
Dees_Troy3f5c4e82013-02-01 15:16:59 +0000963 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -0400964}
965
bigbiffce8f83c2015-12-12 18:30:21 -0500966bool TWPartitionManager::Restore_Partition(PartitionSettings *part_settings) {
Dees_Troy4a2a1262012-09-18 09:33:47 -0400967 time_t Start, Stop;
bigbiffce8f83c2015-12-12 18:30:21 -0500968
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -0400969 if (part_settings->adbbackup) {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400970 std::string partName = part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win";
971 LOGINFO("setting backup name: %s\n", partName.c_str());
bigbiff bigbiffb5ecaad2017-03-20 18:53:53 -0400972 part_settings->Part->Set_Backup_FileName(part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win");
973 }
974
Tom Hite5a926722014-09-15 01:31:03 +0000975 TWFunc::SetPerformanceMode(true);
bigbiffce8f83c2015-12-12 18:30:21 -0500976
Dees_Troy4a2a1262012-09-18 09:33:47 -0400977 time(&Start);
Ethan Yonker472f5062016-02-25 13:47:30 -0600978
bigbiffce8f83c2015-12-12 18:30:21 -0500979 if (!part_settings->Part->Restore(part_settings)) {
Tom Hite5a926722014-09-15 01:31:03 +0000980 TWFunc::SetPerformanceMode(false);
Dees_Troy4a2a1262012-09-18 09:33:47 -0400981 return false;
Tom Hite5a926722014-09-15 01:31:03 +0000982 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400983 if (part_settings->Part->Has_SubPartition && !part_settings->adbbackup) {
Dees_Troy8170a922012-09-18 15:40:25 -0400984 std::vector<TWPartition*>::iterator subpart;
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400985 TWPartition *parentPart = part_settings->Part;
Dees_Troy8170a922012-09-18 15:40:25 -0400986
987 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -0400988 part_settings->Part = *subpart;
989 if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) {
990 part_settings->Part = (*subpart);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400991 part_settings->Part->Set_Backup_FileName(part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win");
bigbiffce8f83c2015-12-12 18:30:21 -0500992 if (!(*subpart)->Restore(part_settings)) {
Tom Hite5a926722014-09-15 01:31:03 +0000993 TWFunc::SetPerformanceMode(false);
Dees_Troy8170a922012-09-18 15:40:25 -0400994 return false;
Tom Hite5a926722014-09-15 01:31:03 +0000995 }
Dees_Troy8170a922012-09-18 15:40:25 -0400996 }
997 }
998 }
Dees_Troy4a2a1262012-09-18 09:33:47 -0400999 time(&Stop);
Tom Hite5a926722014-09-15 01:31:03 +00001000 TWFunc::SetPerformanceMode(false);
bigbiffce8f83c2015-12-12 18:30:21 -05001001 gui_msg(Msg("restore_part_done=[{1} done ({2} seconds)]")(part_settings->Part->Backup_Display_Name)((int)difftime(Stop, Start)));
1002
Dees_Troy4a2a1262012-09-18 09:33:47 -04001003 return true;
1004}
1005
Ethan Yonker472f5062016-02-25 13:47:30 -06001006int TWPartitionManager::Run_Restore(const string& Restore_Name) {
bigbiffce8f83c2015-12-12 18:30:21 -05001007 PartitionSettings part_settings;
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001008 int check_digest;
bigbiffce8f83c2015-12-12 18:30:21 -05001009
Dees_Troy4a2a1262012-09-18 09:33:47 -04001010 time_t rStart, rStop;
1011 time(&rStart);
Dees_Troya13d74f2013-03-24 08:54:55 -05001012 string Restore_List, restore_path;
1013 size_t start_pos = 0, end_pos;
bigbiffce8f83c2015-12-12 18:30:21 -05001014
Ethan Yonkerdcf2b672016-09-13 14:41:53 -05001015 part_settings.Backup_Folder = Restore_Name;
bigbiffce8f83c2015-12-12 18:30:21 -05001016 part_settings.Part = NULL;
1017 part_settings.partition_count = 0;
1018 part_settings.total_restore_size = 0;
1019 part_settings.adbbackup = false;
1020 part_settings.PM_Method = PM_RESTORE;
Dees_Troy43d8b002012-09-17 16:00:01 -04001021
Ethan Yonker74db1572015-10-28 12:44:49 -05001022 gui_msg("restore_started=[RESTORE STARTED]");
1023 gui_msg(Msg("restore_folder=Restore folder: '{1}'")(Restore_Name));
Dees_Troy43d8b002012-09-17 16:00:01 -04001024
Dees_Troy4a2a1262012-09-18 09:33:47 -04001025 if (!Mount_Current_Storage(true))
1026 return false;
1027
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001028 DataManager::GetValue(TW_SKIP_DIGEST_CHECK_VAR, check_digest);
1029 if (check_digest > 0) {
1030 // Check Digest files first before restoring to ensure that all of them match before starting a restore
1031 TWFunc::GUI_Operation_Text(TW_VERIFY_DIGEST_TEXT, gui_parse_text("{@verifying_digest}"));
1032 gui_msg("verifying_digest=Verifying Digest");
Dees_Troya13d74f2013-03-24 08:54:55 -05001033 } else {
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001034 gui_msg("skip_digest=Skipping Digest check based on user setting.");
Dees_Troya13d74f2013-03-24 08:54:55 -05001035 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001036 gui_msg("calc_restore=Calculating restore details...");
Dees_Troya13d74f2013-03-24 08:54:55 -05001037 DataManager::GetValue("tw_restore_selected", Restore_List);
bigbiffce8f83c2015-12-12 18:30:21 -05001038
Dees_Troya13d74f2013-03-24 08:54:55 -05001039 if (!Restore_List.empty()) {
1040 end_pos = Restore_List.find(";", start_pos);
1041 while (end_pos != string::npos && start_pos < Restore_List.size()) {
1042 restore_path = Restore_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -05001043 part_settings.Part = Find_Partition_By_Path(restore_path);
1044 if (part_settings.Part != NULL) {
bigbiffce8f83c2015-12-12 18:30:21 -05001045 if (part_settings.Part->Mount_Read_Only) {
1046 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 -05001047 return false;
1048 }
bigbiffce8f83c2015-12-12 18:30:21 -05001049
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001050 string Full_Filename = part_settings.Backup_Folder + "/" + part_settings.Part->Backup_FileName;
1051
1052 if (check_digest > 0 && !twrpDigestDriver::Check_Digest(Full_Filename))
Dees_Troya13d74f2013-03-24 08:54:55 -05001053 return false;
bigbiffce8f83c2015-12-12 18:30:21 -05001054 part_settings.partition_count++;
1055 part_settings.total_restore_size += part_settings.Part->Get_Restore_Size(&part_settings);
1056 if (part_settings.Part->Has_SubPartition) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -04001057 TWPartition *parentPart = part_settings.Part;
Dees_Troya13d74f2013-03-24 08:54:55 -05001058 std::vector<TWPartition*>::iterator subpart;
1059
1060 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
bigbiff bigbiff8fd4b092016-08-30 20:48:53 -04001061 part_settings.Part = *subpart;
1062 if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) {
bigbiff bigbiff56cf5642016-08-19 17:43:45 -04001063 if (check_digest > 0 && !twrpDigestDriver::Check_Digest(Full_Filename))
Dees_Troya13d74f2013-03-24 08:54:55 -05001064 return false;
bigbiffce8f83c2015-12-12 18:30:21 -05001065 part_settings.total_restore_size += (*subpart)->Get_Restore_Size(&part_settings);
Dees_Troya13d74f2013-03-24 08:54:55 -05001066 }
1067 }
1068 }
1069 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001070 gui_msg(Msg(msg::kError, "restore_unable_locate=Unable to locate '{1}' partition for restoring.")(restore_path));
Dees_Troya13d74f2013-03-24 08:54:55 -05001071 }
1072 start_pos = end_pos + 1;
1073 end_pos = Restore_List.find(";", start_pos);
Dees_Troy4a2a1262012-09-18 09:33:47 -04001074 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001075 }
Dees_Troy4a2a1262012-09-18 09:33:47 -04001076
bigbiffce8f83c2015-12-12 18:30:21 -05001077 if (part_settings.partition_count == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001078 gui_err("no_part_restore=No partitions selected for restore.");
Dees_Troy4a2a1262012-09-18 09:33:47 -04001079 return false;
1080 }
1081
bigbiffce8f83c2015-12-12 18:30:21 -05001082 gui_msg(Msg("restore_part_count=Restoring {1} partitions...")(part_settings.partition_count));
1083 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 +00001084 DataManager::SetProgress(0.0);
bigbiffce8f83c2015-12-12 18:30:21 -05001085 ProgressTracking progress(part_settings.total_restore_size);
1086 part_settings.progress = &progress;
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001087
Dees_Troya13d74f2013-03-24 08:54:55 -05001088 start_pos = 0;
1089 if (!Restore_List.empty()) {
1090 end_pos = Restore_List.find(";", start_pos);
1091 while (end_pos != string::npos && start_pos < Restore_List.size()) {
1092 restore_path = Restore_List.substr(start_pos, end_pos - start_pos);
bigbiffce8f83c2015-12-12 18:30:21 -05001093
1094 part_settings.Part = Find_Partition_By_Path(restore_path);
1095 if (part_settings.Part != NULL) {
1096 part_settings.partition_count++;
bigbiffce8f83c2015-12-12 18:30:21 -05001097 if (!Restore_Partition(&part_settings))
Dees_Troya13d74f2013-03-24 08:54:55 -05001098 return false;
1099 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001100 gui_msg(Msg(msg::kError, "restore_unable_locate=Unable to locate '{1}' partition for restoring.")(restore_path));
Dees_Troya13d74f2013-03-24 08:54:55 -05001101 }
1102 start_pos = end_pos + 1;
1103 end_pos = Restore_List.find(";", start_pos);
1104 }
1105 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001106 TWFunc::GUI_Operation_Text(TW_UPDATE_SYSTEM_DETAILS_TEXT, gui_parse_text("{@updating_system_details}"));
Captain Throwback9d6feb52018-07-27 10:05:24 -04001107 UnMount_By_Path(Get_Android_Root_Path(), false);
Dees_Troy43d8b002012-09-17 16:00:01 -04001108 Update_System_Details();
Dees_Troyd0384ef2012-10-12 12:15:42 -04001109 UnMount_Main_Partitions();
Dees_Troy4a2a1262012-09-18 09:33:47 -04001110 time(&rStop);
Matt Mower3c366972015-12-25 19:28:31 -06001111 gui_msg(Msg(msg::kHighlight, "restore_completed=[RESTORE COMPLETED IN {1} SECONDS]")((int)difftime(rStop,rStart)));
Ethan Yonker1b7a31b2014-07-03 15:09:22 -05001112 DataManager::SetValue("tw_file_progress", "");
bigbiffce8f83c2015-12-12 18:30:21 -05001113
Dees_Troy63c8df72012-09-10 14:02:05 -04001114 return true;
Dees_Troy51a0e822012-09-05 15:24:24 -04001115}
1116
1117void TWPartitionManager::Set_Restore_Files(string Restore_Name) {
Dees_Troy63c8df72012-09-10 14:02:05 -04001118 // Start with the default values
Dees_Troya13d74f2013-03-24 08:54:55 -05001119 string Restore_List;
Dees_Troy83bd4832013-05-04 12:39:56 +00001120 bool get_date = true, check_encryption = true;
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001121 bool adbbackup = false;
Dees_Troy83bd4832013-05-04 12:39:56 +00001122
1123 DataManager::SetValue("tw_restore_encrypted", 0);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001124 if (twadbbu::Check_ADB_Backup_File(Restore_Name)) {
1125 vector<string> adb_files;
1126 adb_files = twadbbu::Get_ADB_Backup_Files(Restore_Name);
1127 for (unsigned int i = 0; i < adb_files.size(); ++i) {
1128 string adb_restore_file = adb_files.at(i);
1129 std::size_t pos = adb_restore_file.find_first_of(".");
1130 std::string path = "/" + adb_restore_file.substr(0, pos);
1131 Restore_List = path + ";";
1132 TWPartition* Part = Find_Partition_By_Path(path);
1133 Part->Backup_FileName = TWFunc::Get_Filename(adb_restore_file);
1134 adbbackup = true;
1135 }
1136 DataManager::SetValue("tw_enable_adb_backup", 1);
Dees_Troy63c8df72012-09-10 14:02:05 -04001137 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001138 else {
1139 DIR* d;
1140 d = opendir(Restore_Name.c_str());
1141 if (d == NULL)
Dees_Troy63c8df72012-09-10 14:02:05 -04001142 {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001143 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Name)(strerror(errno)));
1144 return;
Dees_Troy63c8df72012-09-10 14:02:05 -04001145 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001146
1147 struct dirent* de;
1148 while ((de = readdir(d)) != NULL)
Dees_Troy63c8df72012-09-10 14:02:05 -04001149 {
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001150 // Strip off three components
1151 char str[256];
1152 char* label;
1153 char* fstype = NULL;
1154 char* extn = NULL;
1155 char* ptr;
Dees_Troy63c8df72012-09-10 14:02:05 -04001156
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001157 strcpy(str, de->d_name);
1158 if (strlen(str) <= 2)
1159 continue;
Dees_Troy83bd4832013-05-04 12:39:56 +00001160
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001161 if (get_date) {
1162 char file_path[255];
1163 struct stat st;
1164
1165 strcpy(file_path, Restore_Name.c_str());
1166 strcat(file_path, "/");
1167 strcat(file_path, str);
1168 stat(file_path, &st);
1169 string backup_date = ctime((const time_t*)(&st.st_mtime));
1170 DataManager::SetValue(TW_RESTORE_FILE_DATE, backup_date);
1171 get_date = false;
Dees_Troy83bd4832013-05-04 12:39:56 +00001172 }
Dees_Troy63c8df72012-09-10 14:02:05 -04001173
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001174 label = str;
1175 ptr = label;
1176 while (*ptr && *ptr != '.') ptr++;
1177 if (*ptr == '.')
1178 {
1179 *ptr = 0x00;
1180 ptr++;
1181 fstype = ptr;
1182 }
1183 while (*ptr && *ptr != '.') ptr++;
1184 if (*ptr == '.')
1185 {
1186 *ptr = 0x00;
1187 ptr++;
1188 extn = ptr;
1189 }
Dees_Troy63c8df72012-09-10 14:02:05 -04001190
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001191 if (fstype == NULL || extn == NULL || strcmp(fstype, "log") == 0) continue;
1192 int extnlength = strlen(extn);
1193 if (extnlength != 3 && extnlength != 6) continue;
1194 if (extnlength >= 3 && strncmp(extn, "win", 3) != 0) continue;
1195 //if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue;
Dees_Troy63c8df72012-09-10 14:02:05 -04001196
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001197 if (check_encryption) {
1198 string filename = Restore_Name + "/";
1199 filename += de->d_name;
1200 if (TWFunc::Get_File_Type(filename) == 2) {
1201 LOGINFO("'%s' is encrypted\n", filename.c_str());
1202 DataManager::SetValue("tw_restore_encrypted", 1);
1203 }
1204 }
1205 if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue;
1206
1207 TWPartition* Part = Find_Partition_By_Path(label);
1208 if (Part == NULL)
1209 {
1210 gui_msg(Msg(msg::kError, "unable_locate_part_backup_name=Unable to locate partition by backup name: '{1}'")(label));
1211 continue;
1212 }
1213
1214 Part->Backup_FileName = de->d_name;
1215 if (strlen(extn) > 3) {
1216 Part->Backup_FileName.resize(Part->Backup_FileName.size() - strlen(extn) + 3);
1217 }
1218
1219 if (!Part->Is_SubPartition)
1220 Restore_List += Part->Backup_Path + ";";
1221 }
1222 closedir(d);
Dees_Troy63c8df72012-09-10 14:02:05 -04001223 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001224
1225 if (adbbackup) {
1226 Restore_List = "ADB_Backup;";
1227 adbbackup = false;
1228 }
Dees_Troy63c8df72012-09-10 14:02:05 -04001229
Dees_Troya13d74f2013-03-24 08:54:55 -05001230 // Set the final value
1231 DataManager::SetValue("tw_restore_list", Restore_List);
1232 DataManager::SetValue("tw_restore_selected", Restore_List);
Dees_Troy51a0e822012-09-05 15:24:24 -04001233 return;
1234}
1235
1236int TWPartitionManager::Wipe_By_Path(string Path) {
Dees_Troy63c8df72012-09-10 14:02:05 -04001237 std::vector<TWPartition*>::iterator iter;
1238 int ret = false;
1239 bool found = false;
Dees_Troy38bd7602012-09-14 13:33:53 -04001240 string Local_Path = TWFunc::Get_Root_Path(Path);
Dees_Troy63c8df72012-09-10 14:02:05 -04001241
1242 // Iterate through all partitions
1243 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy657c3092012-09-10 20:32:10 -04001244 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
Dees_Troye58d5262012-09-21 12:27:57 -04001245 if (Path == "/and-sec")
1246 ret = (*iter)->Wipe_AndSec();
1247 else
1248 ret = (*iter)->Wipe();
Dees_Troy63c8df72012-09-10 14:02:05 -04001249 found = true;
1250 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1251 (*iter)->Wipe();
1252 }
1253 }
1254 if (found) {
1255 return ret;
1256 } else
Ethan Yonker74db1572015-10-28 12:44:49 -05001257 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 -04001258 return false;
Dees_Troy51a0e822012-09-05 15:24:24 -04001259}
1260
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001261int TWPartitionManager::Wipe_By_Path(string Path, string New_File_System) {
1262 std::vector<TWPartition*>::iterator iter;
1263 int ret = false;
1264 bool found = false;
1265 string Local_Path = TWFunc::Get_Root_Path(Path);
1266
1267 // Iterate through all partitions
1268 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1269 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
1270 if (Path == "/and-sec")
1271 ret = (*iter)->Wipe_AndSec();
1272 else
1273 ret = (*iter)->Wipe(New_File_System);
1274 found = true;
1275 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1276 (*iter)->Wipe(New_File_System);
1277 }
1278 }
1279 if (found) {
1280 return ret;
1281 } else
Ethan Yonker74db1572015-10-28 12:44:49 -05001282 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 -05001283 return false;
1284}
1285
Dees_Troy51a0e822012-09-05 15:24:24 -04001286int TWPartitionManager::Factory_Reset(void) {
Dees_Troy63c8df72012-09-10 14:02:05 -04001287 std::vector<TWPartition*>::iterator iter;
1288 int ret = true;
1289
1290 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy38bd7602012-09-14 13:33:53 -04001291 if ((*iter)->Wipe_During_Factory_Reset && (*iter)->Is_Present) {
Ethan Yonker89583ef2015-08-26 09:01:59 -05001292#ifdef TW_OEM_BUILD
1293 if ((*iter)->Mount_Point == "/data") {
1294 if (!(*iter)->Wipe_Encryption())
1295 ret = false;
1296 } else {
1297#endif
1298 if (!(*iter)->Wipe())
1299 ret = false;
1300#ifdef TW_OEM_BUILD
1301 }
1302#endif
Dees_Troy094207a2012-09-26 12:00:39 -04001303 } else if ((*iter)->Has_Android_Secure) {
1304 if (!(*iter)->Wipe_AndSec())
1305 ret = false;
Dees_Troy63c8df72012-09-10 14:02:05 -04001306 }
1307 }
Ethan Yonker9fa76ba2016-06-30 14:05:43 -05001308 TWFunc::check_and_run_script("/sbin/factoryreset.sh", "Factory Reset Script");
Dees_Troy63c8df72012-09-10 14:02:05 -04001309 return ret;
Dees_Troy51a0e822012-09-05 15:24:24 -04001310}
1311
Dees_Troy38bd7602012-09-14 13:33:53 -04001312int TWPartitionManager::Wipe_Dalvik_Cache(void) {
1313 struct stat st;
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001314 vector <string> dir;
Dees_Troy38bd7602012-09-14 13:33:53 -04001315
1316 if (!Mount_By_Path("/data", true))
1317 return false;
1318
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001319 dir.push_back("/data/dalvik-cache");
Ethan Yonkerff2b7882016-12-10 09:04:41 -06001320 if (Mount_By_Path("/cache", false)) {
1321 dir.push_back("/cache/dalvik-cache");
1322 dir.push_back("/cache/dc");
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001323 }
Ethan Yonkerff2b7882016-12-10 09:04:41 -06001324
Dees_Troy38bd7602012-09-14 13:33:53 -04001325 TWPartition* sdext = Find_Partition_By_Path("/sd-ext");
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001326 if (sdext && sdext->Is_Present && sdext->Mount(false))
1327 {
1328 if (stat("/sd-ext/dalvik-cache", &st) == 0)
1329 {
Ethan Yonkerff2b7882016-12-10 09:04:41 -06001330 dir.push_back("/sd-ext/dalvik-cache");
1331 }
1332 }
1333
1334 gui_msg("wiping_dalvik=Wiping Dalvik Cache Directories...");
1335 for (unsigned i = 0; i < dir.size(); ++i) {
1336 if (stat(dir.at(i).c_str(), &st) == 0) {
1337 TWFunc::removeDir(dir.at(i), false);
1338 gui_msg(Msg("cleaned=Cleaned: {1}...")(dir.at(i)));
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001339 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02001340 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001341 gui_msg("dalvik_done=-- Dalvik Cache Directories Wipe Complete!");
Dees_Troy38bd7602012-09-14 13:33:53 -04001342 return true;
1343}
1344
1345int TWPartitionManager::Wipe_Rotate_Data(void) {
1346 if (!Mount_By_Path("/data", true))
1347 return false;
1348
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001349 unlink("/data/misc/akmd*");
1350 unlink("/data/misc/rild*");
Dees_Troy2673cec2013-04-02 20:22:16 +00001351 gui_print("Rotation data wiped.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001352 return true;
1353}
1354
1355int TWPartitionManager::Wipe_Battery_Stats(void) {
1356 struct stat st;
1357
1358 if (!Mount_By_Path("/data", true))
1359 return false;
1360
1361 if (0 != stat("/data/system/batterystats.bin", &st)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001362 gui_print("No Battery Stats Found. No Need To Wipe.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001363 } else {
1364 remove("/data/system/batterystats.bin");
Dees_Troy2673cec2013-04-02 20:22:16 +00001365 gui_print("Cleared battery stats.\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001366 }
1367 return true;
1368}
1369
Dees_Troy2ff5a8d2012-09-26 14:53:02 -04001370int TWPartitionManager::Wipe_Android_Secure(void) {
1371 std::vector<TWPartition*>::iterator iter;
1372 int ret = false;
1373 bool found = false;
1374
1375 // Iterate through all partitions
1376 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1377 if ((*iter)->Has_Android_Secure) {
1378 ret = (*iter)->Wipe_AndSec();
1379 found = true;
1380 }
1381 }
1382 if (found) {
1383 return ret;
1384 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001385 gui_err("no_andsec=No android secure partitions found.");
Dees_Troy2ff5a8d2012-09-26 14:53:02 -04001386 }
1387 return false;
1388}
1389
Dees_Troy38bd7602012-09-14 13:33:53 -04001390int TWPartitionManager::Format_Data(void) {
1391 TWPartition* dat = Find_Partition_By_Path("/data");
1392
1393 if (dat != NULL) {
1394 if (!dat->UnMount(true))
1395 return false;
1396
1397 return dat->Wipe_Encryption();
1398 } else {
Matt Mower3c366972015-12-25 19:28:31 -06001399 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")("/data"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001400 return false;
1401 }
1402 return false;
1403}
1404
1405int TWPartitionManager::Wipe_Media_From_Data(void) {
1406 TWPartition* dat = Find_Partition_By_Path("/data");
1407
1408 if (dat != NULL) {
1409 if (!dat->Has_Data_Media) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001410 LOGERR("This device does not have /data/media\n");
Dees_Troy38bd7602012-09-14 13:33:53 -04001411 return false;
1412 }
1413 if (!dat->Mount(true))
1414 return false;
1415
Ethan Yonker74db1572015-10-28 12:44:49 -05001416 gui_msg("wiping_datamedia=Wiping internal storage -- /data/media...");
Ethan Yonker726a0202014-12-16 20:01:38 -06001417 Remove_MTP_Storage(dat->MTP_Storage_ID);
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001418 TWFunc::removeDir("/data/media", false);
xiaolu9416f4f2015-06-04 08:22:23 +08001419 dat->Recreate_Media_Folder();
Ethan Yonker726a0202014-12-16 20:01:38 -06001420 Add_MTP_Storage(dat->MTP_Storage_ID);
Dees_Troy38bd7602012-09-14 13:33:53 -04001421 return true;
1422 } else {
Matt Mower3c366972015-12-25 19:28:31 -06001423 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")("/data"));
Dees_Troy38bd7602012-09-14 13:33:53 -04001424 return false;
1425 }
1426 return false;
1427}
1428
Ethan Yonker87c7bac2014-05-25 21:41:08 -05001429int TWPartitionManager::Repair_By_Path(string Path, bool Display_Error) {
1430 std::vector<TWPartition*>::iterator iter;
1431 int ret = false;
1432 bool found = false;
1433 string Local_Path = TWFunc::Get_Root_Path(Path);
1434
1435 if (Local_Path == "/tmp" || Local_Path == "/")
1436 return true;
1437
1438 // Iterate through all partitions
1439 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1440 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
1441 ret = (*iter)->Repair();
1442 found = true;
1443 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1444 (*iter)->Repair();
1445 }
1446 }
1447 if (found) {
1448 return ret;
1449 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001450 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 -05001451 } else {
1452 LOGINFO("Repair: Unable to find partition for path '%s'\n", Local_Path.c_str());
1453 }
1454 return false;
1455}
1456
Ethan Yonkera2719152015-05-28 09:44:41 -05001457int TWPartitionManager::Resize_By_Path(string Path, bool Display_Error) {
1458 std::vector<TWPartition*>::iterator iter;
1459 int ret = false;
1460 bool found = false;
1461 string Local_Path = TWFunc::Get_Root_Path(Path);
1462
1463 if (Local_Path == "/tmp" || Local_Path == "/")
1464 return true;
1465
1466 // Iterate through all partitions
1467 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1468 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
1469 ret = (*iter)->Resize();
1470 found = true;
1471 } else if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Local_Path) {
1472 (*iter)->Resize();
1473 }
1474 }
1475 if (found) {
1476 return ret;
1477 } else if (Display_Error) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001478 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 -05001479 } else {
1480 LOGINFO("Resize: Unable to find partition for path '%s'\n", Local_Path.c_str());
1481 }
1482 return false;
1483}
1484
Dees_Troy51a0e822012-09-05 15:24:24 -04001485void TWPartitionManager::Update_System_Details(void) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001486 std::vector<TWPartition*>::iterator iter;
Dees_Troy51127312012-09-08 13:08:49 -04001487 int data_size = 0;
Dees_Troy5bf43922012-09-07 16:07:55 -04001488
Ethan Yonker74db1572015-10-28 12:44:49 -05001489 gui_msg("update_part_details=Updating partition details...");
Dees_Troy5bf43922012-09-07 16:07:55 -04001490 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Ethan Yonker1b190162016-12-05 15:25:19 -06001491 (*iter)->Update_Size(true);
Dees_Troy51127312012-09-08 13:08:49 -04001492 if ((*iter)->Can_Be_Mounted) {
Captain Throwback9d6feb52018-07-27 10:05:24 -04001493 if ((*iter)->Mount_Point == Get_Android_Root_Path()) {
Dees_Troy51127312012-09-08 13:08:49 -04001494 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1495 DataManager::SetValue(TW_BACKUP_SYSTEM_SIZE, backup_display_size);
1496 } else if ((*iter)->Mount_Point == "/data" || (*iter)->Mount_Point == "/datadata") {
1497 data_size += (int)((*iter)->Backup_Size / 1048576LLU);
1498 } else if ((*iter)->Mount_Point == "/cache") {
1499 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1500 DataManager::SetValue(TW_BACKUP_CACHE_SIZE, backup_display_size);
1501 } else if ((*iter)->Mount_Point == "/sd-ext") {
1502 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1503 DataManager::SetValue(TW_BACKUP_SDEXT_SIZE, backup_display_size);
1504 if ((*iter)->Backup_Size == 0) {
1505 DataManager::SetValue(TW_HAS_SDEXT_PARTITION, 0);
1506 DataManager::SetValue(TW_BACKUP_SDEXT_VAR, 0);
1507 } else
1508 DataManager::SetValue(TW_HAS_SDEXT_PARTITION, 1);
Dees_Troye58d5262012-09-21 12:27:57 -04001509 } else if ((*iter)->Has_Android_Secure) {
Dees_Troy8170a922012-09-18 15:40:25 -04001510 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
Dees_Troye58d5262012-09-21 12:27:57 -04001511 DataManager::SetValue(TW_BACKUP_ANDSEC_SIZE, backup_display_size);
Dees_Troy8170a922012-09-18 15:40:25 -04001512 if ((*iter)->Backup_Size == 0) {
1513 DataManager::SetValue(TW_HAS_ANDROID_SECURE, 0);
1514 DataManager::SetValue(TW_BACKUP_ANDSEC_VAR, 0);
1515 } else
1516 DataManager::SetValue(TW_HAS_ANDROID_SECURE, 1);
Dees_Troy2c50e182012-09-26 20:05:28 -04001517 } else if ((*iter)->Mount_Point == "/boot") {
1518 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1519 DataManager::SetValue(TW_BACKUP_BOOT_SIZE, backup_display_size);
1520 if ((*iter)->Backup_Size == 0) {
1521 DataManager::SetValue("tw_has_boot_partition", 0);
1522 DataManager::SetValue(TW_BACKUP_BOOT_VAR, 0);
1523 } else
1524 DataManager::SetValue("tw_has_boot_partition", 1);
Dees_Troy51127312012-09-08 13:08:49 -04001525 }
Dees_Troyaa9cc402012-10-13 12:14:05 -04001526 } else {
1527 // Handle unmountable partitions in case we reset defaults
1528 if ((*iter)->Mount_Point == "/boot") {
1529 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1530 DataManager::SetValue(TW_BACKUP_BOOT_SIZE, backup_display_size);
1531 if ((*iter)->Backup_Size == 0) {
1532 DataManager::SetValue(TW_HAS_BOOT_PARTITION, 0);
1533 DataManager::SetValue(TW_BACKUP_BOOT_VAR, 0);
1534 } else
1535 DataManager::SetValue(TW_HAS_BOOT_PARTITION, 1);
1536 } else if ((*iter)->Mount_Point == "/recovery") {
1537 int backup_display_size = (int)((*iter)->Backup_Size / 1048576LLU);
1538 DataManager::SetValue(TW_BACKUP_RECOVERY_SIZE, backup_display_size);
1539 if ((*iter)->Backup_Size == 0) {
1540 DataManager::SetValue(TW_HAS_RECOVERY_PARTITION, 0);
1541 DataManager::SetValue(TW_BACKUP_RECOVERY_VAR, 0);
1542 } else
1543 DataManager::SetValue(TW_HAS_RECOVERY_PARTITION, 1);
Gary Peck82599a82012-11-21 16:23:12 -08001544 } else if ((*iter)->Mount_Point == "/data") {
1545 data_size += (int)((*iter)->Backup_Size / 1048576LLU);
Dees_Troyaa9cc402012-10-13 12:14:05 -04001546 }
Dees_Troy51127312012-09-08 13:08:49 -04001547 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001548 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001549 gui_msg("update_part_details_done=...done");
Dees_Troy51127312012-09-08 13:08:49 -04001550 DataManager::SetValue(TW_BACKUP_DATA_SIZE, data_size);
1551 string current_storage_path = DataManager::GetCurrentStoragePath();
1552 TWPartition* FreeStorage = Find_Partition_By_Path(current_storage_path);
Dees_Troy8170a922012-09-18 15:40:25 -04001553 if (FreeStorage != NULL) {
1554 // Attempt to mount storage
1555 if (!FreeStorage->Mount(false)) {
Matt Mower2d50cad2015-12-03 22:26:55 -06001556 gui_msg(Msg(msg::kError, "unable_to_mount_storage=Unable to mount storage"));
1557 DataManager::SetValue(TW_STORAGE_FREE_SIZE, 0);
Dees_Troy8170a922012-09-18 15:40:25 -04001558 } else {
1559 DataManager::SetValue(TW_STORAGE_FREE_SIZE, (int)(FreeStorage->Free / 1048576LLU));
1560 }
1561 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00001562 LOGINFO("Unable to find storage partition '%s'.\n", current_storage_path.c_str());
Dees_Troy8170a922012-09-18 15:40:25 -04001563 }
Dees_Troy5bf43922012-09-07 16:07:55 -04001564 if (!Write_Fstab())
Dees_Troy2673cec2013-04-02 20:22:16 +00001565 LOGERR("Error creating fstab\n");
Dees_Troy51a0e822012-09-05 15:24:24 -04001566 return;
1567}
1568
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001569void TWPartitionManager::Post_Decrypt(const string& Block_Device) {
1570 TWPartition* dat = Find_Partition_By_Path("/data");
1571 if (dat != NULL) {
1572 DataManager::SetValue(TW_IS_DECRYPTED, 1);
1573 dat->Is_Decrypted = true;
1574 if (!Block_Device.empty()) {
1575 dat->Decrypted_Block_Device = Block_Device;
1576 gui_msg(Msg("decrypt_success_dev=Data successfully decrypted, new block device: '{1}'")(Block_Device));
1577 } else {
1578 gui_msg("decrypt_success_nodev=Data successfully decrypted");
1579 }
1580 dat->Setup_File_System(false);
1581 dat->Current_File_System = dat->Fstab_File_System; // Needed if we're ignoring blkid because encrypted devices start out as emmc
1582
1583 // Sleep for a bit so that the device will be ready
1584 sleep(1);
1585 if (dat->Has_Data_Media && dat->Mount(false) && TWFunc::Path_Exists("/data/media/0")) {
1586 dat->Storage_Path = "/data/media/0";
1587 dat->Symlink_Path = dat->Storage_Path;
1588 DataManager::SetValue("tw_storage_path", "/data/media/0");
1589 DataManager::SetValue("tw_settings_path", "/data/media/0");
1590 dat->UnMount(false);
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001591 }
1592 Update_System_Details();
nkk71ffb02bd2017-06-04 23:12:16 +03001593 Output_Partition(dat);
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001594 UnMount_Main_Partitions();
1595 } else
1596 LOGERR("Unable to locate data partition.\n");
1597}
1598
Dees_Troy51a0e822012-09-05 15:24:24 -04001599int TWPartitionManager::Decrypt_Device(string Password) {
Dees_Troy5bf43922012-09-07 16:07:55 -04001600#ifdef TW_INCLUDE_CRYPTO
Ethan Yonkerddb63e22017-01-19 14:01:57 -06001601 char crypto_state[PROPERTY_VALUE_MAX], crypto_blkdev[PROPERTY_VALUE_MAX];
Ethan Yonker253368a2014-11-25 15:00:52 -06001602 std::vector<TWPartition*>::iterator iter;
Dees_Troy5bf43922012-09-07 16:07:55 -04001603
Ethan Yonker253368a2014-11-25 15:00:52 -06001604 // Mount any partitions that need to be mounted for decrypt
1605 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1606 if ((*iter)->Mount_To_Decrypt) {
1607 (*iter)->Mount(true);
1608 }
a39552696ff55ce2013-01-08 16:14:56 +00001609 }
oshmouna82a7542018-04-10 17:45:55 +02001610 property_set("twrp.mount_to_decrypt", "1");
a39552696ff55ce2013-01-08 16:14:56 +00001611
Ethan Yonkera1de1492015-11-04 11:58:27 -06001612 property_get("ro.crypto.state", crypto_state, "error");
1613 if (strcmp(crypto_state, "error") == 0) {
1614 property_set("ro.crypto.state", "encrypted");
1615 // Sleep for a bit so that services can start if needed
1616 sleep(1);
1617 }
1618
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001619 if (DataManager::GetIntValue(TW_IS_FBE)) {
1620#ifdef TW_INCLUDE_FBE
1621 if (!Mount_By_Path("/data", true)) // /data has to be mounted for FBE
1622 return -1;
1623 int retry_count = 10;
1624 while (!TWFunc::Path_Exists("/data/system/users/gatekeeper.password.key") && --retry_count)
1625 usleep(2000); // A small sleep is needed after mounting /data to ensure reliable decrypt... maybe because of DE?
1626 int user_id = DataManager::GetIntValue("tw_decrypt_user_id");
1627 LOGINFO("Decrypting FBE for user %i\n", user_id);
1628 if (Decrypt_User(user_id, Password)) {
1629 Post_Decrypt("");
1630 return 0;
1631 }
1632#else
1633 LOGERR("FBE support is not present\n");
1634#endif
1635 return -1;
1636 }
1637
Ethan Yonkerddb63e22017-01-19 14:01:57 -06001638 int pwret = -1;
1639 pid_t pid = fork();
1640 if (pid < 0) {
1641 LOGERR("fork failed\n");
1642 return -1;
1643 } else if (pid == 0) {
1644 // Child process
1645 char cPassword[255];
1646 strcpy(cPassword, Password.c_str());
1647 int ret = cryptfs_check_passwd(cPassword);
1648 exit(ret);
1649 } else {
1650 // Parent
1651 int status;
1652 if (TWFunc::Wait_For_Child_Timeout(pid, &status, "Decrypt", 30))
1653 pwret = -1;
1654 else
1655 pwret = WEXITSTATUS(status) ? -1 : 0;
1656 }
a39552696ff55ce2013-01-08 16:14:56 +00001657
nkk7171c6c502017-01-05 23:55:05 +02001658#ifdef TW_CRYPTO_USE_SYSTEM_VOLD
1659 if (pwret != 0) {
1660 pwret = vold_decrypt(Password);
nkk717d1222a2017-11-06 17:27:21 +02001661 switch (pwret) {
1662 case VD_SUCCESS:
1663 break;
1664 case VD_ERR_MISSING_VDC:
1665 gui_msg(Msg(msg::kError, "decrypt_data_vold_os_missing=Missing files needed for vold decrypt: {1}")("/system/bin/vdc"));
1666 break;
1667 case VD_ERR_MISSING_VOLD:
1668 gui_msg(Msg(msg::kError, "decrypt_data_vold_os_missing=Missing files needed for vold decrypt: {1}")("/system/bin/vold"));
1669 break;
1670 }
nkk7171c6c502017-01-05 23:55:05 +02001671 }
1672#endif // TW_CRYPTO_USE_SYSTEM_VOLD
1673
Ethan Yonker253368a2014-11-25 15:00:52 -06001674 // Unmount any partitions that were needed for decrypt
1675 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1676 if ((*iter)->Mount_To_Decrypt) {
1677 (*iter)->UnMount(false);
1678 }
1679 }
oshmouna82a7542018-04-10 17:45:55 +02001680 property_set("twrp.mount_to_decrypt", "0");
Ethan Yonker253368a2014-11-25 15:00:52 -06001681
a39552696ff55ce2013-01-08 16:14:56 +00001682 if (pwret != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001683 gui_err("fail_decrypt=Failed to decrypt data.");
Dees_Troy5bf43922012-09-07 16:07:55 -04001684 return -1;
1685 }
a39552696ff55ce2013-01-08 16:14:56 +00001686
Dees_Troy5bf43922012-09-07 16:07:55 -04001687 property_get("ro.crypto.fs_crypto_blkdev", crypto_blkdev, "error");
1688 if (strcmp(crypto_blkdev, "error") == 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001689 LOGERR("Error retrieving decrypted data block device.\n");
Dees_Troy5bf43922012-09-07 16:07:55 -04001690 } else {
Ethan Yonkerbd7492d2016-12-07 13:55:01 -06001691 Post_Decrypt(crypto_blkdev);
Dees_Troy5bf43922012-09-07 16:07:55 -04001692 }
1693 return 0;
1694#else
Ethan Yonker74db1572015-10-28 12:44:49 -05001695 gui_err("no_crypto_support=No crypto support was compiled into this build.");
Dees_Troy5bf43922012-09-07 16:07:55 -04001696 return -1;
1697#endif
Dees_Troy51a0e822012-09-05 15:24:24 -04001698 return 1;
Dees_Troy51127312012-09-08 13:08:49 -04001699}
1700
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001701int TWPartitionManager::Fix_Contexts(void) {
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001702 std::vector<TWPartition*>::iterator iter;
1703 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1704 if ((*iter)->Has_Data_Media) {
1705 if ((*iter)->Mount(true)) {
1706 if (fixContexts::fixDataMediaContexts((*iter)->Mount_Point) != 0)
1707 return -1;
1708 }
1709 }
1710 }
Dees_Troy1a650e62012-10-19 20:54:32 -04001711 UnMount_Main_Partitions();
Ethan Yonker74db1572015-10-28 12:44:49 -05001712 gui_msg("done=Done.");
Ethan Yonkerb5fab762016-01-28 14:03:33 -06001713 return 0;
bigbiff bigbiffa0f8a592012-10-09 21:01:03 -04001714}
1715
Ethan Yonker66a19492015-12-10 10:19:45 -06001716TWPartition* TWPartitionManager::Find_Next_Storage(string Path, bool Exclude_Data_Media) {
Ethan Yonker47360be2014-04-01 10:34:34 -05001717 std::vector<TWPartition*>::iterator iter = Partitions.begin();
1718
1719 if (!Path.empty()) {
1720 string Search_Path = TWFunc::Get_Root_Path(Path);
1721 for (; iter != Partitions.end(); iter++) {
Matt Mower9a561dd2016-02-22 21:25:51 -06001722 if ((*iter)->Mount_Point == Search_Path) {
Ethan Yonker47360be2014-04-01 10:34:34 -05001723 iter++;
1724 break;
1725 }
1726 }
1727 }
1728
1729 for (; iter != Partitions.end(); iter++) {
Ethan Yonker66a19492015-12-10 10:19:45 -06001730 if (Exclude_Data_Media && (*iter)->Has_Data_Media) {
1731 // do nothing, do not return this type of partition
1732 } else if ((*iter)->Is_Storage && (*iter)->Is_Present) {
Ethan Yonker47360be2014-04-01 10:34:34 -05001733 return (*iter);
1734 }
1735 }
1736
1737 return NULL;
1738}
1739
Dees_Troyd21618c2012-10-14 18:48:49 -04001740int TWPartitionManager::Open_Lun_File(string Partition_Path, string Lun_File) {
Dees_Troyd21618c2012-10-14 18:48:49 -04001741 TWPartition* Part = Find_Partition_By_Path(Partition_Path);
1742
1743 if (Part == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001744 LOGINFO("Unable to locate '%s' for USB storage mode.", Partition_Path.c_str());
1745 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 -04001746 return false;
1747 }
Ethan Yonker47360be2014-04-01 10:34:34 -05001748 LOGINFO("USB mount '%s', '%s' > '%s'\n", Partition_Path.c_str(), Part->Actual_Block_Device.c_str(), Lun_File.c_str());
1749 if (!Part->UnMount(true) || !Part->Is_Present)
Dees_Troyd21618c2012-10-14 18:48:49 -04001750 return false;
1751
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001752 if (TWFunc::write_to_file(Lun_File, Part->Actual_Block_Device)) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001753 LOGERR("Unable to write to ums lunfile '%s': (%s)\n", Lun_File.c_str(), strerror(errno));
Dees_Troyd21618c2012-10-14 18:48:49 -04001754 return false;
1755 }
Dees_Troyd21618c2012-10-14 18:48:49 -04001756 return true;
1757}
1758
Dees_Troy8170a922012-09-18 15:40:25 -04001759int TWPartitionManager::usb_storage_enable(void) {
Dees_Troy8170a922012-09-18 15:40:25 -04001760 char lun_file[255];
Dees_Troyd21618c2012-10-14 18:48:49 -04001761 bool has_multiple_lun = false;
Dees_Troy8170a922012-09-18 15:40:25 -04001762
Ethan Yonker47360be2014-04-01 10:34:34 -05001763 string Lun_File_str = CUSTOM_LUN_FILE;
1764 size_t found = Lun_File_str.find("%");
1765 if (found != string::npos) {
1766 sprintf(lun_file, CUSTOM_LUN_FILE, 1);
1767 if (TWFunc::Path_Exists(lun_file))
1768 has_multiple_lun = true;
1769 }
Ethan Yonker726a0202014-12-16 20:01:38 -06001770 mtp_was_enabled = TWFunc::Toggle_MTP(false); // Must disable MTP for USB Storage
Ethan Yonker47360be2014-04-01 10:34:34 -05001771 if (!has_multiple_lun) {
1772 LOGINFO("Device doesn't have multiple lun files, mount current storage\n");
1773 sprintf(lun_file, CUSTOM_LUN_FILE, 0);
1774 if (TWFunc::Get_Root_Path(DataManager::GetCurrentStoragePath()) == "/data") {
Ethan Yonker66a19492015-12-10 10:19:45 -06001775 TWPartition* Mount = Find_Next_Storage("", true);
Ethan Yonker47360be2014-04-01 10:34:34 -05001776 if (Mount) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001777 if (!Open_Lun_File(Mount->Mount_Point, lun_file)) {
1778 goto error_handle;
1779 }
Ethan Yonker47360be2014-04-01 10:34:34 -05001780 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001781 gui_err("unable_locate_storage=Unable to locate storage device.");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001782 goto error_handle;
Ethan Yonker47360be2014-04-01 10:34:34 -05001783 }
1784 } else if (!Open_Lun_File(DataManager::GetCurrentStoragePath(), lun_file)) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001785 goto error_handle;
Dees_Troy8170a922012-09-18 15:40:25 -04001786 }
Dees_Troy8170a922012-09-18 15:40:25 -04001787 } else {
Ethan Yonker47360be2014-04-01 10:34:34 -05001788 LOGINFO("Device has multiple lun files\n");
1789 TWPartition* Mount1;
1790 TWPartition* Mount2;
Dees_Troy8170a922012-09-18 15:40:25 -04001791 sprintf(lun_file, CUSTOM_LUN_FILE, 0);
Ethan Yonker66a19492015-12-10 10:19:45 -06001792 Mount1 = Find_Next_Storage("", true);
Ethan Yonker47360be2014-04-01 10:34:34 -05001793 if (Mount1) {
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001794 if (!Open_Lun_File(Mount1->Mount_Point, lun_file)) {
1795 goto error_handle;
1796 }
Matt Moweree717062014-04-26 01:46:46 -05001797 sprintf(lun_file, CUSTOM_LUN_FILE, 1);
Ethan Yonker66a19492015-12-10 10:19:45 -06001798 Mount2 = Find_Next_Storage(Mount1->Mount_Point, true);
Matt Mower1fdcdb72016-01-25 20:53:47 -06001799 if (Mount2 && Mount2->Mount_Point != Mount1->Mount_Point) {
Matt Moweree717062014-04-26 01:46:46 -05001800 Open_Lun_File(Mount2->Mount_Point, lun_file);
Ethan Yonker47360be2014-04-01 10:34:34 -05001801 }
1802 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05001803 gui_err("unable_locate_storage=Unable to locate storage device.");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001804 goto error_handle;
Ethan Yonker47360be2014-04-01 10:34:34 -05001805 }
Dees_Troy8170a922012-09-18 15:40:25 -04001806 }
Matt Mowerb6ef4782014-11-06 02:24:36 -06001807 property_set("sys.storage.ums_enabled", "1");
HandyMenny37d42992014-10-26 22:15:59 +01001808 property_set("sys.usb.config", "mass_storage,adb");
Dees_Troy8170a922012-09-18 15:40:25 -04001809 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001810error_handle:
1811 if (mtp_was_enabled)
1812 if (!Enable_MTP())
1813 Disable_MTP();
1814 return false;
Dees_Troy8170a922012-09-18 15:40:25 -04001815}
1816
1817int TWPartitionManager::usb_storage_disable(void) {
Dees_Troy2673cec2013-04-02 20:22:16 +00001818 int index, ret;
1819 char lun_file[255], ch[2] = {0, 0};
1820 string str = ch;
Dees_Troy8170a922012-09-18 15:40:25 -04001821
1822 for (index=0; index<2; index++) {
1823 sprintf(lun_file, CUSTOM_LUN_FILE, index);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001824 ret = TWFunc::write_to_file(lun_file, str);
Dees_Troy2673cec2013-04-02 20:22:16 +00001825 if (ret < 0) {
1826 break;
Dees_Troy8170a922012-09-18 15:40:25 -04001827 }
Dees_Troy8170a922012-09-18 15:40:25 -04001828 }
Dees_Troye58d5262012-09-21 12:27:57 -04001829 Mount_All_Storage();
1830 Update_System_Details();
Dees_Troycfd73ef2012-10-12 16:52:00 -04001831 UnMount_Main_Partitions();
Matt Mowerd9cb9062013-12-14 20:34:45 -06001832 property_set("sys.storage.ums_enabled", "0");
HandyMenny37d42992014-10-26 22:15:59 +01001833 property_set("sys.usb.config", "adb");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001834 if (mtp_was_enabled)
1835 if (!Enable_MTP())
1836 Disable_MTP();
Dees_Troy2673cec2013-04-02 20:22:16 +00001837 if (ret < 0 && index == 0) {
1838 LOGERR("Unable to write to ums lunfile '%s'.", lun_file);
1839 return false;
1840 } else {
1841 return true;
1842 }
Dees_Troy8170a922012-09-18 15:40:25 -04001843 return true;
Dees_Troy812660f2012-09-20 09:55:17 -04001844}
1845
1846void TWPartitionManager::Mount_All_Storage(void) {
1847 std::vector<TWPartition*>::iterator iter;
1848
1849 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
1850 if ((*iter)->Is_Storage)
1851 (*iter)->Mount(false);
1852 }
Dees_Troy2c50e182012-09-26 20:05:28 -04001853}
Dees_Troy9350b8d2012-09-27 12:38:38 -04001854
Dees_Troyd0384ef2012-10-12 12:15:42 -04001855void TWPartitionManager::UnMount_Main_Partitions(void) {
1856 // Unmounts system and data if data is not data/media
1857 // Also unmounts boot if boot is mountable
Dees_Troy2673cec2013-04-02 20:22:16 +00001858 LOGINFO("Unmounting main partitions...\n");
Dees_Troyd0384ef2012-10-12 12:15:42 -04001859
1860 TWPartition* Boot_Partition = Find_Partition_By_Path("/boot");
1861
Captain Throwback9d6feb52018-07-27 10:05:24 -04001862 UnMount_By_Path(Get_Android_Root_Path(), true);
Ethan Yonker6277c792014-09-15 14:54:30 -05001863 if (!datamedia)
1864 UnMount_By_Path("/data", true);
1865
Dees_Troyd0384ef2012-10-12 12:15:42 -04001866 if (Boot_Partition != NULL && Boot_Partition->Can_Be_Mounted)
1867 Boot_Partition->UnMount(true);
1868}
1869
Dees_Troy9350b8d2012-09-27 12:38:38 -04001870int TWPartitionManager::Partition_SDCard(void) {
Matt Mower23d8aae2017-01-06 14:30:33 -06001871 char temp[255];
Ethan Yonker483e9f42016-01-11 22:21:18 -06001872 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 -04001873 int ext, swap, total_size = 0, fat_size;
Dees_Troy9350b8d2012-09-27 12:38:38 -04001874
Ethan Yonker74db1572015-10-28 12:44:49 -05001875 gui_msg("start_partition_sd=Partitioning SD Card...");
Ethan Yonker483e9f42016-01-11 22:21:18 -06001876
1877 // Locate and validate device to partition
1878 TWPartition* SDCard = Find_Partition_By_Path(DataManager::GetCurrentStoragePath());
1879
Ethan Yonker66a19492015-12-10 10:19:45 -06001880 if (SDCard->Is_Adopted_Storage)
1881 SDCard->Revert_Adopted();
1882
Ethan Yonker1eff6cd2014-09-15 13:30:42 -05001883 if (SDCard == NULL || !SDCard->Removable || SDCard->Has_Data_Media) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001884 gui_err("partition_sd_locate=Unable to locate device to partition.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04001885 return false;
1886 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001887
1888 // Unmount everything
Dees_Troy9350b8d2012-09-27 12:38:38 -04001889 if (!SDCard->UnMount(true))
1890 return false;
1891 TWPartition* SDext = Find_Partition_By_Path("/sd-ext");
1892 if (SDext != NULL) {
1893 if (!SDext->UnMount(true))
1894 return false;
1895 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001896 char* swappath = getenv("SWAPPATH");
1897 if (swappath != NULL) {
1898 LOGINFO("Unmounting swap at '%s'\n", swappath);
1899 umount(swappath);
1900 }
Vojtech Bocek05534202013-09-11 08:11:56 +02001901
Ethan Yonker483e9f42016-01-11 22:21:18 -06001902 // Determine block device
1903 if (SDCard->Alternate_Block_Device.empty()) {
1904 SDCard->Find_Actual_Block_Device();
1905 Device = SDCard->Actual_Block_Device;
1906 // Just use the root block device
1907 Device.resize(strlen("/dev/block/mmcblkX"));
1908 } else {
1909 Device = SDCard->Alternate_Block_Device;
1910 }
Dees_Troy9350b8d2012-09-27 12:38:38 -04001911
1912 // Find the size of the block device:
Ethan Yonker483e9f42016-01-11 22:21:18 -06001913 total_size = (int)(TWFunc::IOCTL_Get_Block_Size(Device.c_str()) / (1048576));
Dees_Troy9350b8d2012-09-27 12:38:38 -04001914
1915 DataManager::GetValue("tw_sdext_size", ext);
1916 DataManager::GetValue("tw_swap_size", swap);
1917 DataManager::GetValue("tw_sdpart_file_system", ext_format);
1918 fat_size = total_size - ext - swap;
Ethan Yonker483e9f42016-01-11 22:21:18 -06001919 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);
1920
1921 // Determine partition sizes
1922 if (swap == 0 && ext == 0) {
1923 fat_str = "-0";
1924 } else {
1925 memset(temp, 0, sizeof(temp));
1926 sprintf(temp, "%i", fat_size);
1927 fat_str = temp;
1928 fat_str += "MB";
1929 }
1930 if (swap == 0) {
1931 ext_str = "-0";
1932 } else {
1933 memset(temp, 0, sizeof(temp));
1934 sprintf(temp, "%i", ext);
1935 ext_str = "+";
1936 ext_str += temp;
1937 ext_str += "MB";
1938 }
1939
Dees_Troy9350b8d2012-09-27 12:38:38 -04001940 if (ext + swap > total_size) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001941 gui_err("ext_swap_size=EXT + Swap size is larger than sdcard size.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04001942 return false;
1943 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001944
Ethan Yonker74db1572015-10-28 12:44:49 -05001945 gui_msg("remove_part_table=Removing partition table...");
Ethan Yonker483e9f42016-01-11 22:21:18 -06001946 Command = "sgdisk --zap-all " + Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001947 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001948 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001949 gui_err("unable_rm_part=Unable to remove partition table.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04001950 Update_System_Details();
1951 return false;
1952 }
Ethan Yonker74db1572015-10-28 12:44:49 -05001953 gui_msg(Msg("create_part=Creating {1} partition...")("FAT32"));
Captain Throwback9643a802016-05-27 11:44:51 -04001954 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 +00001955 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001956 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001957 gui_msg(Msg(msg::kError, "unable_to_create_part=Unable to create {1} partition.")("FAT32"));
Dees_Troy9350b8d2012-09-27 12:38:38 -04001958 return false;
1959 }
1960 if (ext > 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001961 gui_msg(Msg("create_part=Creating {1} partition...")("EXT"));
Ethan Yonker483e9f42016-01-11 22:21:18 -06001962 Command = "sgdisk --new=0:0:" + ext_str + " --change-name=0:\"Linux filesystem\" " + Device;
Dees_Troy2673cec2013-04-02 20:22:16 +00001963 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001964 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001965 gui_msg(Msg(msg::kError, "unable_to_create_part=Unable to create {1} partition.")("EXT"));
Dees_Troy9350b8d2012-09-27 12:38:38 -04001966 Update_System_Details();
1967 return false;
1968 }
1969 }
1970 if (swap > 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001971 gui_msg(Msg("create_part=Creating {1} partition...")("swap"));
Ethan Yonker483e9f42016-01-11 22:21:18 -06001972 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 +00001973 LOGINFO("Command is: '%s'\n", Command.c_str());
Vojtech Bocek05534202013-09-11 08:11:56 +02001974 if (TWFunc::Exec_Cmd(Command) != 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05001975 gui_msg(Msg(msg::kError, "unable_to_create_part=Unable to create {1} partition.")("swap"));
Dees_Troy9350b8d2012-09-27 12:38:38 -04001976 Update_System_Details();
1977 return false;
1978 }
1979 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06001980
1981 // Convert GPT to MBR
1982 Command = "sgdisk --gpttombr " + Device;
1983 if (TWFunc::Exec_Cmd(Command) != 0)
1984 LOGINFO("Failed to covert partition GPT to MBR\n");
1985
1986 // Tell the kernel to rescan the partition table
1987 int fd = open(Device.c_str(), O_RDONLY);
1988 ioctl(fd, BLKRRPART, 0);
1989 close(fd);
1990
1991 string format_device = Device;
1992 if (Device.substr(0, 17) == "/dev/block/mmcblk")
1993 format_device += "p";
1994
1995 // Format new partitions to proper file system
1996 if (fat_size > 0) {
1997 Command = "mkfs.fat " + format_device + "1";
1998 TWFunc::Exec_Cmd(Command);
1999 }
Dees_Troy9350b8d2012-09-27 12:38:38 -04002000 if (ext > 0) {
2001 if (SDext == NULL) {
Ethan Yonker483e9f42016-01-11 22:21:18 -06002002 Command = "mke2fs -t " + ext_format + " -m 0 " + format_device + "2";
2003 gui_msg(Msg("format_sdext_as=Formatting sd-ext as {1}...")(ext_format));
2004 LOGINFO("Formatting sd-ext after partitioning, command: '%s'\n", Command.c_str());
2005 TWFunc::Exec_Cmd(Command);
2006 } else {
2007 SDext->Wipe(ext_format);
Dees_Troy9350b8d2012-09-27 12:38:38 -04002008 }
Ethan Yonker483e9f42016-01-11 22:21:18 -06002009 }
2010 if (swap > 0) {
2011 Command = "mkswap " + format_device;
2012 if (ext > 0)
2013 Command += "3";
2014 else
2015 Command += "2";
Vojtech Bocek05534202013-09-11 08:11:56 +02002016 TWFunc::Exec_Cmd(Command);
Dees_Troy9350b8d2012-09-27 12:38:38 -04002017 }
2018
Ethan Yonker483e9f42016-01-11 22:21:18 -06002019 // recreate TWRP folder and rewrite settings - these will be gone after sdcard is partitioned
2020 if (SDCard->Mount(true)) {
2021 string TWRP_Folder = SDCard->Mount_Point + "/TWRP";
2022 mkdir(TWRP_Folder.c_str(), 0777);
2023 DataManager::Flush();
2024 }
2025
Dees_Troy9350b8d2012-09-27 12:38:38 -04002026 Update_System_Details();
Ethan Yonker74db1572015-10-28 12:44:49 -05002027 gui_msg("part_complete=Partitioning complete.");
Dees_Troy9350b8d2012-09-27 12:38:38 -04002028 return true;
bigbiff bigbiffa0f8a592012-10-09 21:01:03 -04002029}
Dees_Troya13d74f2013-03-24 08:54:55 -05002030
2031void TWPartitionManager::Get_Partition_List(string ListType, std::vector<PartitionList> *Partition_List) {
2032 std::vector<TWPartition*>::iterator iter;
2033 if (ListType == "mount") {
2034 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002035 if ((*iter)->Can_Be_Mounted) {
Dees_Troya13d74f2013-03-24 08:54:55 -05002036 struct PartitionList part;
2037 part.Display_Name = (*iter)->Display_Name;
2038 part.Mount_Point = (*iter)->Mount_Point;
2039 part.selected = (*iter)->Is_Mounted();
2040 Partition_List->push_back(part);
2041 }
2042 }
2043 } else if (ListType == "storage") {
2044 char free_space[255];
2045 string Current_Storage = DataManager::GetCurrentStoragePath();
2046 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2047 if ((*iter)->Is_Storage) {
2048 struct PartitionList part;
2049 sprintf(free_space, "%llu", (*iter)->Free / 1024 / 1024);
2050 part.Display_Name = (*iter)->Storage_Name + " (";
2051 part.Display_Name += free_space;
2052 part.Display_Name += "MB)";
2053 part.Mount_Point = (*iter)->Storage_Path;
2054 if ((*iter)->Storage_Path == Current_Storage)
2055 part.selected = 1;
2056 else
2057 part.selected = 0;
2058 Partition_List->push_back(part);
2059 }
2060 }
2061 } else if (ListType == "backup") {
2062 char backup_size[255];
Dees_Troy9e0b71c2013-04-08 13:35:37 +00002063 unsigned long long Backup_Size;
Dees_Troya13d74f2013-03-24 08:54:55 -05002064 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
Dees_Troy9e0b71c2013-04-08 13:35:37 +00002065 if ((*iter)->Can_Be_Backed_Up && !(*iter)->Is_SubPartition && (*iter)->Is_Present) {
Dees_Troya13d74f2013-03-24 08:54:55 -05002066 struct PartitionList part;
Dees_Troy9e0b71c2013-04-08 13:35:37 +00002067 Backup_Size = (*iter)->Backup_Size;
2068 if ((*iter)->Has_SubPartition) {
2069 std::vector<TWPartition*>::iterator subpart;
2070
2071 for (subpart = Partitions.begin(); subpart != Partitions.end(); subpart++) {
2072 if ((*subpart)->Is_SubPartition && (*subpart)->Can_Be_Backed_Up && (*subpart)->Is_Present && (*subpart)->SubPartition_Of == (*iter)->Mount_Point)
2073 Backup_Size += (*subpart)->Backup_Size;
2074 }
2075 }
2076 sprintf(backup_size, "%llu", Backup_Size / 1024 / 1024);
Dees_Troya13d74f2013-03-24 08:54:55 -05002077 part.Display_Name = (*iter)->Backup_Display_Name + " (";
2078 part.Display_Name += backup_size;
2079 part.Display_Name += "MB)";
2080 part.Mount_Point = (*iter)->Backup_Path;
2081 part.selected = 0;
2082 Partition_List->push_back(part);
2083 }
2084 }
2085 } else if (ListType == "restore") {
2086 string Restore_List, restore_path;
2087 TWPartition* restore_part = NULL;
2088
2089 DataManager::GetValue("tw_restore_list", Restore_List);
2090 if (!Restore_List.empty()) {
2091 size_t start_pos = 0, end_pos = Restore_List.find(";", start_pos);
2092 while (end_pos != string::npos && start_pos < Restore_List.size()) {
2093 restore_path = Restore_List.substr(start_pos, end_pos - start_pos);
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04002094 struct PartitionList part;
2095 if (restore_path.compare("ADB_Backup") == 0) {
2096 part.Display_Name = "ADB Backup";
2097 part.Mount_Point = "ADB Backup";
2098 part.selected = 1;
2099 Partition_List->push_back(part);
2100 break;
2101 }
Dees_Troy59df9262013-06-19 14:53:57 -05002102 if ((restore_part = Find_Partition_By_Path(restore_path)) != NULL) {
Dees Troy4159aed2014-02-28 17:24:43 +00002103 if ((restore_part->Backup_Name == "recovery" && !restore_part->Can_Be_Backed_Up) || restore_part->Is_SubPartition) {
Dees_Troya13d74f2013-03-24 08:54:55 -05002104 // Don't allow restore of recovery (causes problems on some devices)
Dees_Troy59df9262013-06-19 14:53:57 -05002105 // Don't add subpartitions to the list of items
Dees_Troya13d74f2013-03-24 08:54:55 -05002106 } else {
Dees_Troya13d74f2013-03-24 08:54:55 -05002107 part.Display_Name = restore_part->Backup_Display_Name;
2108 part.Mount_Point = restore_part->Backup_Path;
2109 part.selected = 1;
2110 Partition_List->push_back(part);
2111 }
2112 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002113 gui_msg(Msg(msg::kError, "restore_unable_locate=Unable to locate '{1}' partition for restoring.")(restore_path));
Dees_Troya13d74f2013-03-24 08:54:55 -05002114 }
2115 start_pos = end_pos + 1;
2116 end_pos = Restore_List.find(";", start_pos);
2117 }
2118 }
2119 } else if (ListType == "wipe") {
2120 struct PartitionList dalvik;
Ethan Yonker74db1572015-10-28 12:44:49 -05002121 dalvik.Display_Name = gui_parse_text("{@dalvik}");
Dees_Troya13d74f2013-03-24 08:54:55 -05002122 dalvik.Mount_Point = "DALVIK";
2123 dalvik.selected = 0;
2124 Partition_List->push_back(dalvik);
2125 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2126 if ((*iter)->Wipe_Available_in_GUI && !(*iter)->Is_SubPartition) {
2127 struct PartitionList part;
2128 part.Display_Name = (*iter)->Display_Name;
2129 part.Mount_Point = (*iter)->Mount_Point;
2130 part.selected = 0;
2131 Partition_List->push_back(part);
2132 }
2133 if ((*iter)->Has_Android_Secure) {
2134 struct PartitionList part;
2135 part.Display_Name = (*iter)->Backup_Display_Name;
2136 part.Mount_Point = (*iter)->Backup_Path;
2137 part.selected = 0;
2138 Partition_List->push_back(part);
2139 }
Dees_Troy74fb2e92013-04-15 14:35:47 +00002140 if ((*iter)->Has_Data_Media) {
2141 struct PartitionList datamedia;
2142 datamedia.Display_Name = (*iter)->Storage_Name;
2143 datamedia.Mount_Point = "INTERNAL";
2144 datamedia.selected = 0;
2145 Partition_List->push_back(datamedia);
2146 }
Dees_Troya13d74f2013-03-24 08:54:55 -05002147 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002148 } else if (ListType == "flashimg") {
2149 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2150 if ((*iter)->Can_Flash_Img && (*iter)->Is_Present) {
2151 struct PartitionList part;
2152 part.Display_Name = (*iter)->Backup_Display_Name;
2153 part.Mount_Point = (*iter)->Backup_Path;
2154 part.selected = 0;
2155 Partition_List->push_back(part);
2156 }
2157 }
Dees_Troya13d74f2013-03-24 08:54:55 -05002158 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +00002159 LOGERR("Unknown list type '%s' requested for TWPartitionManager::Get_Partition_List\n", ListType.c_str());
Dees_Troya13d74f2013-03-24 08:54:55 -05002160 }
2161}
2162
2163int TWPartitionManager::Fstab_Processed(void) {
2164 return Partitions.size();
2165}
Dees_Troyd93bda52013-07-03 19:55:19 +00002166
2167void TWPartitionManager::Output_Storage_Fstab(void) {
2168 std::vector<TWPartition*>::iterator iter;
2169 char storage_partition[255];
2170 string Temp;
2171 FILE *fp = fopen("/cache/recovery/storage.fstab", "w");
2172
2173 if (fp == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002174 gui_msg(Msg(msg::kError, "unable_to_open=Unable to open '{1}'.")("/cache/recovery/storage.fstab"));
Dees_Troyd93bda52013-07-03 19:55:19 +00002175 return;
2176 }
2177
2178 // Iterate through all partitions
2179 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2180 if ((*iter)->Is_Storage) {
2181 Temp = (*iter)->Storage_Path + ";" + (*iter)->Storage_Name + ";\n";
2182 strcpy(storage_partition, Temp.c_str());
2183 fwrite(storage_partition, sizeof(storage_partition[0]), strlen(storage_partition) / sizeof(storage_partition[0]), fp);
2184 }
2185 }
2186 fclose(fp);
Vojtech Bocekfafb0c52013-07-25 22:53:02 +02002187}
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002188
2189TWPartition *TWPartitionManager::Get_Default_Storage_Partition()
2190{
2191 TWPartition *res = NULL;
2192 for (std::vector<TWPartition*>::iterator iter = Partitions.begin(); iter != Partitions.end(); ++iter) {
Matt Mowera8a89d12016-12-30 18:10:37 -06002193 if (!(*iter)->Is_Storage)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002194 continue;
2195
Matt Mowera8a89d12016-12-30 18:10:37 -06002196 if ((*iter)->Is_Settings_Storage)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002197 return *iter;
2198
Matt Mowera8a89d12016-12-30 18:10:37 -06002199 if (!res)
Vojtech Bocek93cb1ef2014-05-12 15:41:52 +02002200 res = *iter;
2201 }
2202 return res;
2203}
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002204
2205bool TWPartitionManager::Enable_MTP(void) {
2206#ifdef TW_HAS_MTP
Ethan Yonker8dfa7772014-09-04 21:48:41 -05002207 if (mtppid) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002208 gui_err("mtp_already_enabled=MTP already enabled");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002209 return true;
2210 }
Ethan Yonker726a0202014-12-16 20:01:38 -06002211
2212 int mtppipe[2];
2213
2214 if (pipe(mtppipe) < 0) {
2215 LOGERR("Error creating MTP pipe\n");
2216 return false;
2217 }
2218
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002219 char old_value[PROPERTY_VALUE_MAX];
Matt Mowere07f0102017-02-23 17:40:00 -06002220 property_get("sys.usb.config", old_value, "");
2221 if (strcmp(old_value, "mtp,adb") != 0) {
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002222 char vendor[PROPERTY_VALUE_MAX];
2223 char product[PROPERTY_VALUE_MAX];
2224 property_set("sys.usb.config", "none");
2225 property_get("usb.vendor", vendor, "18D1");
2226 property_get("usb.product.mtpadb", product, "4EE2");
2227 string vendorstr = vendor;
2228 string productstr = product;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002229 TWFunc::write_to_file("/sys/class/android_usb/android0/idVendor", vendorstr);
2230 TWFunc::write_to_file("/sys/class/android_usb/android0/idProduct", productstr);
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002231 property_set("sys.usb.config", "mtp,adb");
2232 }
Matt Mower653a1702017-02-16 10:38:52 -06002233 /* To enable MTP debug, use the twrp command line feature:
Ethan Yonker6d154c42014-09-03 14:19:43 -05002234 * twrp set tw_mtp_debug 1
2235 */
2236 twrpMtp *mtp = new twrpMtp(DataManager::GetIntValue("tw_mtp_debug"));
Ethan Yonker1b039202015-01-30 10:08:48 -06002237 mtppid = mtp->forkserver(mtppipe);
2238 if (mtppid) {
2239 close(mtppipe[0]); // Host closes read side
2240 mtp_write_fd = mtppipe[1];
2241 DataManager::SetValue("tw_mtp_enabled", 1);
2242 Add_All_MTP_Storage();
2243 return true;
Ethan Yonker726a0202014-12-16 20:01:38 -06002244 } else {
2245 close(mtppipe[0]);
2246 close(mtppipe[1]);
Ethan Yonker74db1572015-10-28 12:44:49 -05002247 gui_err("mtp_fail=Failed to enable MTP");
Ethan Yonker1b039202015-01-30 10:08:48 -06002248 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002249 }
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002250#else
Ethan Yonker74db1572015-10-28 12:44:49 -05002251 gui_err("no_mtp=MTP support not included");
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002252#endif
2253 DataManager::SetValue("tw_mtp_enabled", 0);
2254 return false;
2255}
2256
Ethan Yonker1b039202015-01-30 10:08:48 -06002257void TWPartitionManager::Add_All_MTP_Storage(void) {
2258#ifdef TW_HAS_MTP
2259 std::vector<TWPartition*>::iterator iter;
2260
2261 if (!mtppid)
2262 return; // MTP is not enabled
2263
2264 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2265 if ((*iter)->Is_Storage && (*iter)->Is_Present && (*iter)->Mount(false))
2266 Add_Remove_MTP_Storage((*iter), MTP_MESSAGE_ADD_STORAGE);
2267 }
2268#else
2269 return;
2270#endif
2271}
2272
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002273bool TWPartitionManager::Disable_MTP(void) {
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002274 char old_value[PROPERTY_VALUE_MAX];
Matt Mowere07f0102017-02-23 17:40:00 -06002275 property_get("sys.usb.config", old_value, "");
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002276 if (strcmp(old_value, "adb") != 0) {
2277 char vendor[PROPERTY_VALUE_MAX];
2278 char product[PROPERTY_VALUE_MAX];
2279 property_set("sys.usb.config", "none");
2280 property_get("usb.vendor", vendor, "18D1");
Matt Mowere07f0102017-02-23 17:40:00 -06002281 property_get("usb.product.adb", product, "D001");
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002282 string vendorstr = vendor;
2283 string productstr = product;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002284 TWFunc::write_to_file("/sys/class/android_usb/android0/idVendor", vendorstr);
2285 TWFunc::write_to_file("/sys/class/android_usb/android0/idProduct", productstr);
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002286 usleep(2000);
2287 }
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002288#ifdef TW_HAS_MTP
Ethan Yonker8dfa7772014-09-04 21:48:41 -05002289 if (mtppid) {
Ethan Yonker8613dc02014-09-11 09:28:20 -05002290 LOGINFO("Disabling MTP\n");
2291 int status;
2292 kill(mtppid, SIGKILL);
Ethan Yonker8dfa7772014-09-04 21:48:41 -05002293 mtppid = 0;
Ethan Yonker8613dc02014-09-11 09:28:20 -05002294 // We don't care about the exit value, but this prevents a zombie process
2295 waitpid(mtppid, &status, 0);
Ethan Yonker726a0202014-12-16 20:01:38 -06002296 close(mtp_write_fd);
2297 mtp_write_fd = -1;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002298 }
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002299#endif
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002300 property_set("sys.usb.config", "adb");
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002301#ifdef TW_HAS_MTP
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002302 DataManager::SetValue("tw_mtp_enabled", 0);
2303 return true;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002304#endif
Ethan Yonkerdf7abac2014-12-29 10:48:17 -06002305 return false;
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04002306}
Ethan Yonker726a0202014-12-16 20:01:38 -06002307
2308TWPartition* TWPartitionManager::Find_Partition_By_MTP_Storage_ID(unsigned int Storage_ID) {
2309 std::vector<TWPartition*>::iterator iter;
2310
2311 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2312 if ((*iter)->MTP_Storage_ID == Storage_ID)
2313 return (*iter);
2314 }
2315 return NULL;
2316}
2317
2318bool TWPartitionManager::Add_Remove_MTP_Storage(TWPartition* Part, int message_type) {
2319#ifdef TW_HAS_MTP
2320 struct mtpmsg mtp_message;
2321
2322 if (!mtppid)
2323 return false; // MTP is disabled
2324
2325 if (mtp_write_fd < 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002326 LOGINFO("MTP: mtp_write_fd is not set\n");
Ethan Yonker726a0202014-12-16 20:01:38 -06002327 return false;
2328 }
2329
2330 if (Part) {
Ethan Yonker4bfabab2014-12-29 09:15:37 -06002331 if (Part->MTP_Storage_ID == 0)
2332 return false;
Ethan Yonker726a0202014-12-16 20:01:38 -06002333 if (message_type == MTP_MESSAGE_REMOVE_STORAGE) {
2334 mtp_message.message_type = MTP_MESSAGE_REMOVE_STORAGE; // Remove
2335 LOGINFO("sending message to remove %i\n", Part->MTP_Storage_ID);
2336 mtp_message.storage_id = Part->MTP_Storage_ID;
2337 if (write(mtp_write_fd, &mtp_message, sizeof(mtp_message)) <= 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002338 LOGINFO("error sending message to remove storage %i\n", Part->MTP_Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002339 return false;
2340 } else {
2341 LOGINFO("Message sent, remove storage ID: %i\n", Part->MTP_Storage_ID);
2342 return true;
2343 }
2344 } else if (message_type == MTP_MESSAGE_ADD_STORAGE && Part->Is_Mounted()) {
2345 mtp_message.message_type = MTP_MESSAGE_ADD_STORAGE; // Add
2346 mtp_message.storage_id = Part->MTP_Storage_ID;
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002347 if (Part->Storage_Path.size() >= sizeof(mtp_message.path)) {
2348 LOGERR("Storage path '%s' too large for mtpmsg\n", Part->Storage_Path.c_str());
2349 return false;
2350 }
2351 strcpy(mtp_message.path, Part->Storage_Path.c_str());
2352 if (Part->Storage_Name.size() >= sizeof(mtp_message.display)) {
2353 LOGERR("Storage name '%s' too large for mtpmsg\n", Part->Storage_Name.c_str());
2354 return false;
2355 }
2356 strcpy(mtp_message.display, Part->Storage_Name.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -06002357 mtp_message.maxFileSize = Part->Get_Max_FileSize();
Ethan Yonker1b039202015-01-30 10:08:48 -06002358 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 -06002359 if (write(mtp_write_fd, &mtp_message, sizeof(mtp_message)) <= 0) {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002360 LOGINFO("error sending message to add storage %i\n", Part->MTP_Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002361 return false;
2362 } else {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002363 LOGINFO("Message sent, add storage ID: %i '%s'\n", Part->MTP_Storage_ID, mtp_message.path);
Ethan Yonker726a0202014-12-16 20:01:38 -06002364 return true;
2365 }
2366 } else {
2367 LOGERR("Unknown MTP message type: %i\n", message_type);
2368 }
2369 } else {
2370 // This hopefully never happens as the error handling should
2371 // occur in the calling function.
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002372 LOGINFO("TWPartitionManager::Add_Remove_MTP_Storage NULL partition given\n");
Ethan Yonker726a0202014-12-16 20:01:38 -06002373 }
2374 return true;
2375#else
Ethan Yonker74db1572015-10-28 12:44:49 -05002376 gui_err("no_mtp=MTP support not included");
Ethan Yonker726a0202014-12-16 20:01:38 -06002377 DataManager::SetValue("tw_mtp_enabled", 0);
2378 return false;
2379#endif
2380}
2381
2382bool TWPartitionManager::Add_MTP_Storage(string Mount_Point) {
2383#ifdef TW_HAS_MTP
2384 TWPartition* Part = PartitionManager.Find_Partition_By_Path(Mount_Point);
2385 if (Part) {
2386 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_ADD_STORAGE);
2387 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002388 LOGINFO("TWFunc::Add_MTP_Storage unable to locate partition for '%s'\n", Mount_Point.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -06002389 }
2390#endif
2391 return false;
2392}
2393
2394bool TWPartitionManager::Add_MTP_Storage(unsigned int Storage_ID) {
2395#ifdef TW_HAS_MTP
2396 TWPartition* Part = PartitionManager.Find_Partition_By_MTP_Storage_ID(Storage_ID);
2397 if (Part) {
2398 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_ADD_STORAGE);
2399 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002400 LOGINFO("TWFunc::Add_MTP_Storage unable to locate partition for %i\n", Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002401 }
2402#endif
2403 return false;
2404}
2405
2406bool TWPartitionManager::Remove_MTP_Storage(string Mount_Point) {
2407#ifdef TW_HAS_MTP
2408 TWPartition* Part = PartitionManager.Find_Partition_By_Path(Mount_Point);
2409 if (Part) {
2410 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_REMOVE_STORAGE);
2411 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002412 LOGINFO("TWFunc::Remove_MTP_Storage unable to locate partition for '%s'\n", Mount_Point.c_str());
Ethan Yonker726a0202014-12-16 20:01:38 -06002413 }
2414#endif
2415 return false;
2416}
2417
2418bool TWPartitionManager::Remove_MTP_Storage(unsigned int Storage_ID) {
2419#ifdef TW_HAS_MTP
2420 TWPartition* Part = PartitionManager.Find_Partition_By_MTP_Storage_ID(Storage_ID);
2421 if (Part) {
2422 return PartitionManager.Add_Remove_MTP_Storage(Part, MTP_MESSAGE_REMOVE_STORAGE);
2423 } else {
Ethan Yonkerd9ff3c52015-01-21 21:51:20 -06002424 LOGINFO("TWFunc::Remove_MTP_Storage unable to locate partition for %i\n", Storage_ID);
Ethan Yonker726a0202014-12-16 20:01:38 -06002425 }
2426#endif
2427 return false;
2428}
Ethan Yonker96af84a2015-01-05 14:58:36 -06002429
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002430bool TWPartitionManager::Flash_Image(string& path, string& filename) {
Matt Mower23d8aae2017-01-06 14:30:33 -06002431 int partition_count = 0;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002432 TWPartition* flash_part = NULL;
bigbiffce8f83c2015-12-12 18:30:21 -05002433 string Flash_List, flash_path, full_filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002434 size_t start_pos = 0, end_pos = 0;
2435
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002436 full_filename = path + "/" + filename;
Ethan Yonker96af84a2015-01-05 14:58:36 -06002437
bigbiffce8f83c2015-12-12 18:30:21 -05002438 gui_msg("image_flash_start=[IMAGE FLASH STARTED]");
2439 gui_msg(Msg("img_to_flash=Image to flash: '{1}'")(full_filename));
2440
2441 if (!TWFunc::Path_Exists(full_filename)) {
2442 if (!Mount_By_Path(full_filename, true)) {
Ethan Yonkerb78fbdf2016-01-15 16:46:35 -06002443 return false;
2444 }
bigbiffce8f83c2015-12-12 18:30:21 -05002445 if (!TWFunc::Path_Exists(full_filename)) {
2446 gui_msg(Msg(msg::kError, "unable_to_locate=Unable to locate {1}.")(full_filename));
Ethan Yonkerb78fbdf2016-01-15 16:46:35 -06002447 return false;
2448 }
2449 }
Ethan Yonker96af84a2015-01-05 14:58:36 -06002450
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002451 PartitionSettings part_settings;
2452 part_settings.Backup_Folder = path;
2453 unsigned long long total_bytes = TWFunc::Get_File_Size(full_filename);
2454 ProgressTracking progress(total_bytes);
2455 part_settings.progress = &progress;
2456 part_settings.adbbackup = false;
2457 part_settings.PM_Method = PM_RESTORE;
2458
Ethan Yonker74db1572015-10-28 12:44:49 -05002459 gui_msg("calc_restore=Calculating restore details...");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002460 DataManager::GetValue("tw_flash_partition", Flash_List);
2461 if (!Flash_List.empty()) {
2462 end_pos = Flash_List.find(";", start_pos);
2463 while (end_pos != string::npos && start_pos < Flash_List.size()) {
2464 flash_path = Flash_List.substr(start_pos, end_pos - start_pos);
2465 flash_part = Find_Partition_By_Path(flash_path);
2466 if (flash_part != NULL) {
2467 partition_count++;
2468 if (partition_count > 1) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002469 gui_err("too_many_flash=Too many partitions selected for flashing.");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002470 return false;
2471 }
2472 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002473 gui_msg(Msg(msg::kError, "flash_unable_locate=Unable to locate '{1}' partition for flashing.")(flash_path));
Ethan Yonker96af84a2015-01-05 14:58:36 -06002474 return false;
2475 }
2476 start_pos = end_pos + 1;
2477 end_pos = Flash_List.find(";", start_pos);
2478 }
2479 }
2480
2481 if (partition_count == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -05002482 gui_err("no_part_flash=No partitions selected for flashing.");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002483 return false;
2484 }
2485
2486 DataManager::SetProgress(0.0);
2487 if (flash_part) {
Ethan Yonkere080c1f2016-09-19 13:50:25 -05002488 flash_part->Backup_FileName = filename;
2489 if (!flash_part->Flash_Image(&part_settings))
Ethan Yonker96af84a2015-01-05 14:58:36 -06002490 return false;
2491 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -05002492 gui_err("invalid_flash=Invalid flash partition specified.");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002493 return false;
2494 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002495 gui_highlight("flash_done=IMAGE FLASH COMPLETED]");
Ethan Yonker96af84a2015-01-05 14:58:36 -06002496 return true;
2497}
Ethan Yonker74db1572015-10-28 12:44:49 -05002498
2499void TWPartitionManager::Translate_Partition(const char* path, const char* resource_name, const char* default_value) {
2500 TWPartition* part = PartitionManager.Find_Partition_By_Path(path);
2501 if (part) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002502 if (part->Is_Adopted_Storage) {
2503 part->Display_Name = part->Display_Name + " - " + gui_lookup("data", "Data");
2504 part->Backup_Display_Name = part->Display_Name;
2505 part->Storage_Name = part->Storage_Name + " - " + gui_lookup("adopted_storage", "Adopted Storage");
2506 } else {
2507 part->Display_Name = gui_lookup(resource_name, default_value);
2508 part->Backup_Display_Name = part->Display_Name;
2509 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002510 }
2511}
2512
2513void TWPartitionManager::Translate_Partition(const char* path, const char* resource_name, const char* default_value, const char* storage_resource_name, const char* storage_default_value) {
2514 TWPartition* part = PartitionManager.Find_Partition_By_Path(path);
2515 if (part) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002516 if (part->Is_Adopted_Storage) {
Ethan Yonker01f4e032017-02-03 15:30:52 -06002517 part->Backup_Display_Name = part->Display_Name + " - " + gui_lookup("data_backup", "Data (excl. storage)");
Ethan Yonker66a19492015-12-10 10:19:45 -06002518 part->Display_Name = part->Display_Name + " - " + gui_lookup("data", "Data");
Ethan Yonker66a19492015-12-10 10:19:45 -06002519 part->Storage_Name = part->Storage_Name + " - " + gui_lookup("adopted_storage", "Adopted Storage");
2520 } else {
2521 part->Display_Name = gui_lookup(resource_name, default_value);
2522 part->Backup_Display_Name = part->Display_Name;
2523 if (part->Is_Storage)
2524 part->Storage_Name = gui_lookup(storage_resource_name, storage_default_value);
2525 }
Ethan Yonker74db1572015-10-28 12:44:49 -05002526 }
2527}
2528
Ethan Yonker01f4e032017-02-03 15:30:52 -06002529void 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) {
2530 TWPartition* part = PartitionManager.Find_Partition_By_Path(path);
2531 if (part) {
2532 if (part->Is_Adopted_Storage) {
2533 part->Backup_Display_Name = part->Display_Name + " - " + gui_lookup(backup_name, backup_default);
2534 part->Display_Name = part->Display_Name + " - " + gui_lookup("data", "Data");
2535 part->Storage_Name = part->Storage_Name + " - " + gui_lookup("adopted_storage", "Adopted Storage");
2536 } else {
2537 part->Display_Name = gui_lookup(resource_name, default_value);
2538 part->Backup_Display_Name = gui_lookup(backup_name, backup_default);
2539 if (part->Is_Storage)
2540 part->Storage_Name = gui_lookup(storage_resource_name, storage_default_value);
2541 }
2542 }
2543}
2544
Ethan Yonker74db1572015-10-28 12:44:49 -05002545void TWPartitionManager::Translate_Partition_Display_Names() {
Ethan Yonker66a19492015-12-10 10:19:45 -06002546 LOGINFO("Translating partition display names\n");
Ethan Yonker74db1572015-10-28 12:44:49 -05002547 Translate_Partition("/system", "system", "System");
2548 Translate_Partition("/system_image", "system_image", "System Image");
2549 Translate_Partition("/vendor", "vendor", "Vendor");
2550 Translate_Partition("/vendor_image", "vendor_image", "Vendor Image");
2551 Translate_Partition("/cache", "cache", "Cache");
Ethan Yonker74db1572015-10-28 12:44:49 -05002552 Translate_Partition("/boot", "boot", "Boot");
2553 Translate_Partition("/recovery", "recovery", "Recovery");
2554 if (!datamedia) {
Ethan Yonker01f4e032017-02-03 15:30:52 -06002555 Translate_Partition("/data", "data", "Data", "internal", "Internal Storage");
Ethan Yonker74db1572015-10-28 12:44:49 -05002556 Translate_Partition("/sdcard", "sdcard", "SDCard", "sdcard", "SDCard");
2557 Translate_Partition("/internal_sd", "sdcard", "SDCard", "sdcard", "SDCard");
2558 Translate_Partition("/internal_sdcard", "sdcard", "SDCard", "sdcard", "SDCard");
2559 Translate_Partition("/emmc", "sdcard", "SDCard", "sdcard", "SDCard");
Ethan Yonker01f4e032017-02-03 15:30:52 -06002560 } else {
2561 Translate_Partition("/data", "data", "Data", "internal", "Internal Storage", "data_backup", "Data (excl. storage)");
Ethan Yonker74db1572015-10-28 12:44:49 -05002562 }
Ethan Yonker01f4e032017-02-03 15:30:52 -06002563 Translate_Partition("/external_sd", "microsd", "Micro SDCard", "microsd", "Micro SDCard", "data_backup", "Data (excl. storage)");
2564 Translate_Partition("/external_sdcard", "microsd", "Micro SDCard", "microsd", "Micro SDCard", "data_backup", "Data (excl. storage)");
Ethan Yonker74db1572015-10-28 12:44:49 -05002565 Translate_Partition("/usb-otg", "usbotg", "USB OTG", "usbotg", "USB OTG");
2566 Translate_Partition("/sd-ext", "sdext", "SD-EXT");
2567
2568 // Android secure is a special case
2569 TWPartition* part = PartitionManager.Find_Partition_By_Path("/and-sec");
2570 if (part)
2571 part->Backup_Display_Name = gui_lookup("android_secure", "Android Secure");
2572
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002573 std::vector<TWPartition*>::iterator sysfs;
2574 for (sysfs = Partitions.begin(); sysfs != Partitions.end(); sysfs++) {
2575 if (!(*sysfs)->Sysfs_Entry.empty()) {
2576 Translate_Partition((*sysfs)->Mount_Point.c_str(), "autostorage", "Storage", "autostorage", "Storage");
2577 }
2578 }
2579
Ethan Yonker74db1572015-10-28 12:44:49 -05002580 // This updates the text on all of the storage selection buttons in the GUI
2581 DataManager::SetBackupFolder();
2582}
Ethan Yonker66a19492015-12-10 10:19:45 -06002583
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002584bool TWPartitionManager::Decrypt_Adopted() {
Ethan Yonker66a19492015-12-10 10:19:45 -06002585#ifdef TW_INCLUDE_CRYPTO
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002586 bool ret = false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002587 if (!Mount_By_Path("/data", false)) {
2588 LOGERR("Cannot decrypt adopted storage because /data will not mount\n");
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002589 return false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002590 }
2591 LOGINFO("Decrypt adopted storage starting\n");
2592 char* xmlFile = PageManager::LoadFileToBuffer("/data/system/storage.xml", NULL);
2593 xml_document<> *doc = NULL;
2594 xml_node<>* volumes = NULL;
Ethan Yonker66a19492015-12-10 10:19:45 -06002595 string Primary_Storage_UUID = "";
2596 if (xmlFile != NULL) {
2597 LOGINFO("successfully loaded storage.xml\n");
2598 doc = new xml_document<>();
2599 doc->parse<0>(xmlFile);
2600 volumes = doc->first_node("volumes");
2601 if (volumes) {
2602 xml_attribute<>* psuuid = volumes->first_attribute("primaryStorageUuid");
2603 if (psuuid) {
2604 Primary_Storage_UUID = psuuid->value();
2605 }
2606 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002607 } else {
2608 LOGINFO("No /data/system/storage.xml for adopted storage\n");
2609 return false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002610 }
2611 std::vector<TWPartition*>::iterator adopt;
2612 for (adopt = Partitions.begin(); adopt != Partitions.end(); adopt++) {
2613 if ((*adopt)->Removable && (*adopt)->Is_Present) {
2614 if ((*adopt)->Decrypt_Adopted() == 0) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002615 ret = true;
Ethan Yonker66a19492015-12-10 10:19:45 -06002616 if (volumes) {
2617 xml_node<>* volume = volumes->first_node("volume");
2618 while (volume) {
2619 xml_attribute<>* guid = volume->first_attribute("partGuid");
2620 if (guid) {
2621 string GUID = (*adopt)->Adopted_GUID.c_str();
2622 GUID.insert(8, "-");
2623 GUID.insert(13, "-");
2624 GUID.insert(18, "-");
2625 GUID.insert(23, "-");
2626
2627 if (strcasecmp(GUID.c_str(), guid->value()) == 0) {
2628 xml_attribute<>* attr = volume->first_attribute("nickname");
nkk71ffb02bd2017-06-04 23:12:16 +03002629 if (attr && attr->value() && strlen(attr->value()) > 0) {
Ethan Yonker66a19492015-12-10 10:19:45 -06002630 (*adopt)->Storage_Name = attr->value();
2631 (*adopt)->Display_Name = (*adopt)->Storage_Name;
2632 (*adopt)->Backup_Display_Name = (*adopt)->Storage_Name;
2633 LOGINFO("storage name from storage.xml is '%s'\n", attr->value());
2634 }
2635 attr = volume->first_attribute("fsUuid");
2636 if (attr && !Primary_Storage_UUID.empty() && strcmp(Primary_Storage_UUID.c_str(), attr->value()) == 0) {
2637 TWPartition* Dat = Find_Partition_By_Path("/data");
2638 if (Dat) {
2639 LOGINFO("Internal storage is found on adopted storage '%s'\n", (*adopt)->Display_Name.c_str());
2640 LOGINFO("Changing '%s' to point to '%s'\n", Dat->Symlink_Mount_Point.c_str(), (*adopt)->Storage_Path.c_str());
2641 (*adopt)->Symlink_Mount_Point = Dat->Symlink_Mount_Point;
2642 Dat->Symlink_Mount_Point = "";
2643 // Toggle mounts to ensure that the symlink mount point (probably /sdcard) is mounted to the right location
2644 Dat->UnMount(false);
2645 Dat->Mount(false);
2646 (*adopt)->UnMount(false);
2647 (*adopt)->Mount(false);
Ethan Yonker66a19492015-12-10 10:19:45 -06002648 }
2649 }
2650 break;
2651 }
2652 }
2653 volume = volume->next_sibling("volume");
2654 }
2655 }
nkk71ffb02bd2017-06-04 23:12:16 +03002656 Update_System_Details();
2657 Output_Partition((*adopt));
Ethan Yonker66a19492015-12-10 10:19:45 -06002658 }
2659 }
2660 }
2661 if (xmlFile) {
2662 doc->clear();
2663 delete doc;
2664 free(xmlFile);
2665 }
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002666 return ret;
Ethan Yonker66a19492015-12-10 10:19:45 -06002667#else
2668 LOGINFO("Decrypt_Adopted: no crypto support\n");
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002669 return false;
Ethan Yonker66a19492015-12-10 10:19:45 -06002670#endif
2671}
Ethan Yonkerfcf3f242016-02-16 12:30:26 -06002672
2673void TWPartitionManager::Remove_Partition_By_Path(string Path) {
2674 std::vector<TWPartition*>::iterator iter;
2675 string Local_Path = TWFunc::Get_Root_Path(Path);
2676
2677 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2678 if ((*iter)->Mount_Point == Local_Path || (!(*iter)->Symlink_Mount_Point.empty() && (*iter)->Symlink_Mount_Point == Local_Path)) {
2679 LOGINFO("Found and erasing '%s' from partition list\n", Local_Path.c_str());
2680 Partitions.erase(iter);
2681 return;
2682 }
2683 }
2684}
Ethan Yonker1b190162016-12-05 15:25:19 -06002685
2686void TWPartitionManager::Set_Active_Slot(const string& Slot) {
2687 if (Slot != "A" && Slot != "B") {
2688 LOGERR("Set_Active_Slot invalid slot '%s'\n", Slot.c_str());
2689 return;
2690 }
2691 if (Active_Slot_Display == Slot)
2692 return;
2693 LOGINFO("Setting active slot %s\n", Slot.c_str());
2694#ifdef AB_OTA_UPDATER
2695 if (!Active_Slot_Display.empty()) {
2696 const hw_module_t *hw_module;
2697 boot_control_module_t *module;
2698 int ret;
2699 ret = hw_get_module("bootctrl", &hw_module);
2700 if (ret != 0) {
2701 LOGERR("Error getting bootctrl module.\n");
2702 } else {
2703 module = (boot_control_module_t*) hw_module;
2704 module->init(module);
2705 int slot_number = 0;
2706 if (Slot == "B")
2707 slot_number = 1;
2708 if (module->setActiveBootSlot(module, slot_number))
2709 gui_msg(Msg(msg::kError, "unable_set_boot_slot=Error changing bootloader boot slot to {1}")(Slot));
2710 }
2711 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
2712 }
2713#else
2714 LOGERR("Boot slot feature not present\n");
2715#endif
2716 Active_Slot_Display = Slot;
2717 if (Fstab_Processed())
2718 Update_System_Details();
2719}
2720string TWPartitionManager::Get_Active_Slot_Suffix() {
2721 if (Active_Slot_Display == "A")
2722 return "_a";
2723 return "_b";
2724}
2725string TWPartitionManager::Get_Active_Slot_Display() {
2726 return Active_Slot_Display;
2727}
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002728
Captain Throwback9d6feb52018-07-27 10:05:24 -04002729string TWPartitionManager::Get_Android_Root_Path() {
2730 std::string Android_Root = getenv("ANDROID_ROOT");
2731 if (Android_Root == "")
2732 Android_Root = "/system";
2733 return Android_Root;
2734}
2735
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06002736void TWPartitionManager::Remove_Uevent_Devices(const string& Mount_Point) {
2737 std::vector<TWPartition*>::iterator iter;
2738
2739 for (iter = Partitions.begin(); iter != Partitions.end(); ) {
2740 if ((*iter)->Is_SubPartition && (*iter)->SubPartition_Of == Mount_Point) {
2741 TWPartition *part = *iter;
2742 LOGINFO("%s was removed by uevent data\n", (*iter)->Mount_Point.c_str());
2743 (*iter)->UnMount(false);
2744 rmdir((*iter)->Mount_Point.c_str());
2745 iter = Partitions.erase(iter);
2746 delete part;
2747 } else {
2748 iter++;
2749 }
2750 }
2751}
2752
2753void TWPartitionManager::Handle_Uevent(const Uevent_Block_Data& uevent_data) {
2754 std::vector<TWPartition*>::iterator iter;
2755
2756 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2757 if (!(*iter)->Sysfs_Entry.empty()) {
2758 string device;
2759 size_t wildcard = (*iter)->Sysfs_Entry.find("*");
2760 if (wildcard != string::npos) {
2761 device = (*iter)->Sysfs_Entry.substr(0, wildcard);
2762 } else {
2763 device = (*iter)->Sysfs_Entry;
2764 }
2765 if (device == uevent_data.sysfs_path.substr(0, device.size())) {
2766 // Found a match
2767 if (uevent_data.action == "add") {
2768 (*iter)->Primary_Block_Device = "/dev/block/" + uevent_data.block_device;
2769 (*iter)->Alternate_Block_Device = (*iter)->Primary_Block_Device;
2770 (*iter)->Is_Present = true;
2771 LOGINFO("Found a match '%s' '%s'\n", uevent_data.block_device.c_str(), device.c_str());
2772 if (!Decrypt_Adopted()) {
2773 LOGINFO("No adopted storage so finding actual block device\n");
2774 (*iter)->Find_Actual_Block_Device();
2775 }
2776 return;
2777 } else if (uevent_data.action == "remove") {
2778 (*iter)->Is_Present = false;
2779 (*iter)->Primary_Block_Device = "";
2780 (*iter)->Actual_Block_Device = "";
2781 Remove_Uevent_Devices((*iter)->Mount_Point);
2782 return;
2783 }
2784 }
2785 }
2786 }
2787 LOGINFO("Found no matching fstab entry for uevent device '%s' - %s\n", uevent_data.sysfs_path.c_str(), uevent_data.action.c_str());
2788}
2789
2790void TWPartitionManager::setup_uevent() {
2791 struct sockaddr_nl nls;
2792
2793 if (uevent_pfd.fd >= 0) {
2794 LOGINFO("uevent already set up\n");
2795 return;
2796 }
2797
2798 // Open hotplug event netlink socket
2799 memset(&nls,0,sizeof(struct sockaddr_nl));
2800 nls.nl_family = AF_NETLINK;
2801 nls.nl_pid = getpid();
2802 nls.nl_groups = -1;
2803 uevent_pfd.events = POLLIN;
2804 uevent_pfd.fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
2805 if (uevent_pfd.fd==-1) {
2806 LOGERR("uevent not root\n");
2807 return;
2808 }
2809
2810 // Listen to netlink socket
2811 if (::bind(uevent_pfd.fd, (struct sockaddr *) &nls, sizeof(struct sockaddr_nl)) < 0) {
2812 LOGERR("Bind failed\n");
2813 return;
2814 }
2815 set_select_fd();
2816 Coldboot();
2817}
2818
2819Uevent_Block_Data TWPartitionManager::get_event_block_values(char *buf, int len) {
2820 Uevent_Block_Data ret;
2821 ret.subsystem = "";
2822 char *ptr = buf;
2823 const char *end = buf + len;
2824
2825 buf[len - 1] = '\0';
2826 while (ptr < end) {
2827 if (strncmp(ptr, "ACTION=", strlen("ACTION=")) == 0) {
2828 ptr += strlen("ACTION=");
2829 ret.action = ptr;
2830 } else if (strncmp(ptr, "SUBSYSTEM=", strlen("SUBSYSTEM=")) == 0) {
2831 ptr += strlen("SUBSYSTEM=");
2832 ret.subsystem = ptr;
2833 } else if (strncmp(ptr, "DEVTYPE=", strlen("DEVTYPE=")) == 0) {
2834 ptr += strlen("DEVTYPE=");
2835 ret.type = ptr;
2836 } else if (strncmp(ptr, "DEVPATH=", strlen("DEVPATH=")) == 0) {
2837 ptr += strlen("DEVPATH=");
2838 ret.sysfs_path += ptr;
2839 } else if (strncmp(ptr, "DEVNAME=", strlen("DEVNAME=")) == 0) {
2840 ptr += strlen("DEVNAME=");
2841 ret.block_device += ptr;
2842 } else if (strncmp(ptr, "MAJOR=", strlen("MAJOR=")) == 0) {
2843 ptr += strlen("MAJOR=");
2844 ret.major = atoi(ptr);
2845 } else if (strncmp(ptr, "MINOR=", strlen("MINOR=")) == 0) {
2846 ptr += strlen("MINOR=");
2847 ret.minor = atoi(ptr);
2848 }
2849 ptr += strlen(ptr) + 1;
2850 }
2851 return ret;
2852}
2853
2854void TWPartitionManager::read_uevent() {
2855 char buf[1024];
2856
2857 int len = recv(uevent_pfd.fd, buf, sizeof(buf), MSG_DONTWAIT);
2858 if (len == -1) {
2859 LOGERR("recv error on uevent\n");
2860 return;
2861 }
2862 /*int i = 0; // Print all uevent output for test /debug
2863 while (i<len) {
2864 printf("%s\n", buf+i);
2865 i += strlen(buf+i)+1;
2866 }*/
2867 Uevent_Block_Data uevent_data = get_event_block_values(buf, len);
2868 if (uevent_data.subsystem == "block" && uevent_data.type == "disk") {
2869 PartitionManager.Handle_Uevent(uevent_data);
2870 }
2871}
2872
2873void TWPartitionManager::close_uevent() {
2874 if (uevent_pfd.fd > 0)
2875 close(uevent_pfd.fd);
2876 uevent_pfd.fd = -1;
2877}
2878
2879void TWPartitionManager::Add_Partition(TWPartition* Part) {
2880 Partitions.push_back(Part);
2881}
2882
2883void TWPartitionManager::Coldboot_Scan(std::vector<string> *sysfs_entries, const string& Path, int depth) {
2884 string Real_Path = Path;
2885 char real_path[PATH_MAX];
2886 if (realpath(Path.c_str(), &real_path[0])) {
2887 string Real_Path = real_path;
2888 std::vector<string>::iterator iter;
2889 for (iter = sysfs_entries->begin(); iter != sysfs_entries->end(); iter++) {
2890 if (Real_Path.find((*iter)) != string::npos) {
2891 string Write_Path = Real_Path + "/uevent";
2892 if (TWFunc::Path_Exists(Write_Path)) {
2893 const char* write_val = "add\n";
2894 TWFunc::write_to_file(Write_Path, write_val);
2895 break;
2896 }
2897 }
2898 }
2899 }
2900
2901 DIR* d = opendir(Path.c_str());
2902 if (d != NULL) {
2903 struct dirent* de;
2904 while ((de = readdir(d)) != NULL) {
2905 if (de->d_name[0] == '.' || (de->d_type != DT_DIR && depth > 0))
2906 continue;
2907 if (strlen(de->d_name) >= 4 && (strncmp(de->d_name, "ram", 3) == 0 || strncmp(de->d_name, "loop", 4) == 0))
2908 continue;
2909
2910 string item = Path + "/";
2911 item.append(de->d_name);
2912 Coldboot_Scan(sysfs_entries, item, depth + 1);
2913 }
2914 closedir(d);
2915 }
2916}
2917
2918void TWPartitionManager::Coldboot() {
2919 std::vector<TWPartition*>::iterator iter;
2920 std::vector<string> sysfs_entries;
2921
2922 for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
2923 if (!(*iter)->Sysfs_Entry.empty()) {
2924 size_t wildcard_pos = (*iter)->Sysfs_Entry.find("*");
2925 if (wildcard_pos == string::npos)
2926 wildcard_pos = (*iter)->Sysfs_Entry.size();
2927 sysfs_entries.push_back((*iter)->Sysfs_Entry.substr(0, wildcard_pos));
2928 }
2929 }
2930
2931 if (sysfs_entries.size() > 0)
2932 Coldboot_Scan(&sysfs_entries, "/sys/block", 0);
2933}