blob: f30206bdbd729288d55ae4629c2cff7520bdc843 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
bigbiffdf8436b2020-08-30 16:22:34 -04002 Copyright 2012-2020 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*/
18
Dees_Troy38bd7602012-09-14 13:33:53 -040019#include <stdio.h>
20#include <stdlib.h>
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060021#include <string>
Dees_Troy38bd7602012-09-14 13:33:53 -040022#include <unistd.h>
23#include <vector>
24#include <dirent.h>
25#include <time.h>
Dees_Troy43d8b002012-09-17 16:00:01 -040026#include <errno.h>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050027#include <fcntl.h>
28#include <sys/mount.h>
Dees_Troya58bead2012-09-27 09:49:29 -040029#include <sys/reboot.h>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050030#include <sys/sendfile.h>
31#include <sys/stat.h>
32#include <sys/vfs.h>
Dees_Troy83bd4832013-05-04 12:39:56 +000033#include <sys/types.h>
34#include <sys/wait.h>
bigbiff bigbiff9c754052013-01-09 09:09:08 -050035#include <iostream>
36#include <fstream>
Dees_Troy83bd4832013-05-04 12:39:56 +000037#include <sstream>
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -040038#include <cctype>
bigbiff74a6d0d2015-02-14 20:49:44 -050039#include <algorithm>
bigbiff bigbiff19874f12019-01-08 20:06:57 -050040#include <selinux/label.h>
Adithya Ra327aa72021-12-19 00:49:54 +053041#include <thread>
bigbiff22851b92021-09-01 16:46:57 -040042
43#include <android-base/strings.h>
Adithya Ra327aa72021-12-19 00:49:54 +053044#include <android-base/chrono_utils.h>
bigbiff22851b92021-09-01 16:46:57 -040045
Dees_Troy38bd7602012-09-14 13:33:53 -040046#include "twrp-functions.hpp"
Dees_Troy2673cec2013-04-02 20:22:16 +000047#include "twcommon.h"
Ethan Yonker472f5062016-02-25 13:47:30 -060048#include "gui/gui.hpp"
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060049#ifndef BUILD_TWRPTAR_MAIN
Dees_Troyb46a6842012-09-25 11:06:46 -040050#include "data.hpp"
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060051#include "partitions.hpp"
Dees_Troy3477d712012-09-27 15:44:01 -040052#include "variables.h"
bigbiffdf8436b2020-08-30 16:22:34 -040053#include "bootloader_message/include/bootloader_message/bootloader_message.h"
Tom Hite5a926722014-09-15 01:31:03 +000054#include "cutils/properties.h"
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -050055#include "cutils/android_reboot.h"
56#include <sys/reboot.h>
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060057#endif // ndef BUILD_TWRPTAR_MAIN
Dees_Troy83bd4832013-05-04 12:39:56 +000058#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
59 #include "openaes/inc/oaes_lib.h"
60#endif
Ethan Yonkerf1179622016-08-25 15:32:21 -050061#include "set_metadata.h"
Dees_Troy38bd7602012-09-14 13:33:53 -040062
Dees_Troyb05ddee2013-01-28 20:24:50 +000063extern "C" {
64 #include "libcrecovery/common.h"
65}
66
Chaosmaster461e39f2020-02-07 01:48:13 +010067#ifdef TW_INCLUDE_LIBRESETPROP
bigbiffa05d32c2021-12-25 15:43:34 -050068 #include <resetprop.hpp>
Chaosmaster461e39f2020-02-07 01:48:13 +010069#endif
70
bigbiff bigbiff19874f12019-01-08 20:06:57 -050071struct selabel_handle *selinux_handle;
72
bigbiff bigbiff9c754052013-01-09 09:09:08 -050073/* Execute a command */
bigbiffad58e1b2020-07-06 20:24:34 -040074int TWFunc::Exec_Cmd(const string& cmd, string &result, bool combine_stderr) {
Dees_Troy29a06352013-08-24 12:06:47 +000075 FILE* exec;
76 char buffer[130];
77 int ret = 0;
bigbiffad58e1b2020-07-06 20:24:34 -040078 std::string popen_cmd = cmd;
79 if (combine_stderr)
80 popen_cmd = cmd + " 2>&1";
81 exec = __popen(popen_cmd.c_str(), "r");
82
Matt Mowera8a89d12016-12-30 18:10:37 -060083 while (!feof(exec)) {
Dees_Troy29a06352013-08-24 12:06:47 +000084 if (fgets(buffer, 128, exec) != NULL) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -050085 result += buffer;
Dees_Troyb05ddee2013-01-28 20:24:50 +000086 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -050087 }
Dees_Troy29a06352013-08-24 12:06:47 +000088 ret = __pclose(exec);
89 return ret;
bigbiff bigbiff9c754052013-01-09 09:09:08 -050090}
91
Ethan Yonker7e941582019-03-22 08:18:21 -050092int TWFunc::Exec_Cmd(const string& cmd, bool Show_Errors) {
Vojtech Bocek05534202013-09-11 08:11:56 +020093 pid_t pid;
94 int status;
95 switch(pid = fork())
96 {
97 case -1:
bigbiff bigbiff731df792014-02-20 18:26:13 -050098 LOGERR("Exec_Cmd(): vfork failed: %d!\n", errno);
Vojtech Bocek05534202013-09-11 08:11:56 +020099 return -1;
100 case 0: // child
bigbiffad58e1b2020-07-06 20:24:34 -0400101 execl("/system/bin/sh", "sh", "-c", cmd.c_str(), NULL);
Vojtech Bocek05534202013-09-11 08:11:56 +0200102 _exit(127);
103 break;
104 default:
105 {
Ethan Yonker7e941582019-03-22 08:18:21 -0500106 if (TWFunc::Wait_For_Child(pid, &status, cmd, Show_Errors) != 0)
Vojtech Bocek05534202013-09-11 08:11:56 +0200107 return -1;
108 else
109 return 0;
110 }
111 }
112}
113
Dees_Troy38bd7602012-09-14 13:33:53 -0400114// Returns "file.name" from a full /path/to/file.name
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600115string TWFunc::Get_Filename(const string& Path) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400116 size_t pos = Path.find_last_of("/");
117 if (pos != string::npos) {
118 string Filename;
119 Filename = Path.substr(pos + 1, Path.size() - pos - 1);
120 return Filename;
121 } else
122 return Path;
123}
124
125// Returns "/path/to/" from a full /path/to/file.name
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600126string TWFunc::Get_Path(const string& Path) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400127 size_t pos = Path.find_last_of("/");
128 if (pos != string::npos) {
129 string Pathonly;
130 Pathonly = Path.substr(0, pos + 1);
131 return Pathonly;
132 } else
133 return Path;
134}
135
Ethan Yonker7e941582019-03-22 08:18:21 -0500136int TWFunc::Wait_For_Child(pid_t pid, int *status, string Child_Name, bool Show_Errors) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600137 pid_t rc_pid;
138
139 rc_pid = waitpid(pid, status, 0);
140 if (rc_pid > 0) {
Vojtech Bocek0fdcbec2015-03-20 15:36:40 +0100141 if (WIFSIGNALED(*status)) {
Ethan Yonker7e941582019-03-22 08:18:21 -0500142 if (Show_Errors)
143 gui_msg(Msg(msg::kError, "pid_signal={1} process ended with signal: {2}")(Child_Name)(WTERMSIG(*status))); // Seg fault or some other non-graceful termination
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600144 return -1;
Vojtech Bocek0fdcbec2015-03-20 15:36:40 +0100145 } else if (WEXITSTATUS(*status) == 0) {
146 LOGINFO("%s process ended with RC=%d\n", Child_Name.c_str(), WEXITSTATUS(*status)); // Success
147 } else {
Ethan Yonker7e941582019-03-22 08:18:21 -0500148 if (Show_Errors)
149 gui_msg(Msg(msg::kError, "pid_error={1} process ended with ERROR: {2}")(Child_Name)(WEXITSTATUS(*status))); // Graceful exit, but there was an error
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600150 return -1;
151 }
152 } else { // no PID returned
153 if (errno == ECHILD)
that2252d242015-04-03 22:33:04 +0200154 LOGERR("%s no child process exist\n", Child_Name.c_str());
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600155 else {
that2252d242015-04-03 22:33:04 +0200156 LOGERR("%s Unexpected error %d\n", Child_Name.c_str(), errno);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600157 return -1;
158 }
159 }
160 return 0;
161}
162
Ethan Yonkerddb63e22017-01-19 14:01:57 -0600163int TWFunc::Wait_For_Child_Timeout(pid_t pid, int *status, const string& Child_Name, int timeout) {
164 pid_t retpid = waitpid(pid, status, WNOHANG);
165 for (; retpid == 0 && timeout; --timeout) {
166 sleep(1);
167 retpid = waitpid(pid, status, WNOHANG);
168 }
169 if (retpid == 0 && timeout == 0) {
170 LOGERR("%s took too long, killing process\n", Child_Name.c_str());
171 kill(pid, SIGKILL);
Ethan Yonkerddb63e22017-01-19 14:01:57 -0600172 for (timeout = 5; retpid == 0 && timeout; --timeout) {
173 sleep(1);
174 retpid = waitpid(pid, status, WNOHANG);
175 }
176 if (retpid)
177 LOGINFO("Child process killed successfully\n");
178 else
179 LOGINFO("Child process took too long to kill, may be a zombie process\n");
180 return -1;
181 } else if (retpid > 0) {
182 if (WIFSIGNALED(*status)) {
183 gui_msg(Msg(msg::kError, "pid_signal={1} process ended with signal: {2}")(Child_Name)(WTERMSIG(*status))); // Seg fault or some other non-graceful termination
184 return -1;
185 }
186 } else if (retpid < 0) { // no PID returned
187 if (errno == ECHILD)
188 LOGERR("%s no child process exist\n", Child_Name.c_str());
189 else {
190 LOGERR("%s Unexpected error %d\n", Child_Name.c_str(), errno);
191 return -1;
192 }
193 }
194 return 0;
195}
196
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600197bool TWFunc::Path_Exists(string Path) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600198 struct stat st;
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400199 return stat(Path.c_str(), &st) == 0;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600200}
201
bigbiffce8f83c2015-12-12 18:30:21 -0500202Archive_Type TWFunc::Get_File_Type(string fn) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600203 string::size_type i = 0;
204 int firstbyte = 0, secondbyte = 0;
205 char header[3];
206
207 ifstream f;
208 f.open(fn.c_str(), ios::in | ios::binary);
209 f.get(header, 3);
210 f.close();
211 firstbyte = header[i] & 0xff;
212 secondbyte = header[++i] & 0xff;
213
214 if (firstbyte == 0x1f && secondbyte == 0x8b)
bigbiffce8f83c2015-12-12 18:30:21 -0500215 return COMPRESSED;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600216 else if (firstbyte == 0x4f && secondbyte == 0x41)
bigbiffce8f83c2015-12-12 18:30:21 -0500217 return ENCRYPTED;
218 return UNCOMPRESSED; // default
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600219}
220
221int TWFunc::Try_Decrypting_File(string fn, string password) {
222#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
223 OAES_CTX * ctx = NULL;
224 uint8_t _key_data[32] = "";
225 FILE *f;
226 uint8_t buffer[4096];
227 uint8_t *buffer_out = NULL;
228 uint8_t *ptr = NULL;
229 size_t read_len = 0, out_len = 0;
Matt Mower23d8aae2017-01-06 14:30:33 -0600230 int firstbyte = 0, secondbyte = 0;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600231 size_t _j = 0;
232 size_t _key_data_len = 0;
233
234 // mostly kanged from OpenAES oaes.c
Matt Mowera8a89d12016-12-30 18:10:37 -0600235 for ( _j = 0; _j < 32; _j++ )
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600236 _key_data[_j] = _j + 1;
237 _key_data_len = password.size();
Matt Mowera8a89d12016-12-30 18:10:37 -0600238 if ( 16 >= _key_data_len )
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600239 _key_data_len = 16;
Matt Mowera8a89d12016-12-30 18:10:37 -0600240 else if ( 24 >= _key_data_len )
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600241 _key_data_len = 24;
242 else
Matt Mowera8a89d12016-12-30 18:10:37 -0600243 _key_data_len = 32;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600244 memcpy(_key_data, password.c_str(), password.size());
245
246 ctx = oaes_alloc();
247 if (ctx == NULL) {
248 LOGERR("Failed to allocate OAES\n");
249 return -1;
250 }
251
252 oaes_key_import_data(ctx, _key_data, _key_data_len);
253
254 f = fopen(fn.c_str(), "rb");
255 if (f == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500256 LOGERR("Failed to open '%s' to try decrypt: %s\n", fn.c_str(), strerror(errno));
Matt Mower13a8f0b2015-09-26 15:40:03 -0500257 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600258 return -1;
259 }
260 read_len = fread(buffer, sizeof(uint8_t), 4096, f);
261 if (read_len <= 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500262 LOGERR("Read size during try decrypt failed: %s\n", strerror(errno));
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600263 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500264 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600265 return -1;
266 }
267 if (oaes_decrypt(ctx, buffer, read_len, NULL, &out_len) != OAES_RET_SUCCESS) {
268 LOGERR("Error: Failed to retrieve required buffer size for trying decryption.\n");
269 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500270 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600271 return -1;
272 }
273 buffer_out = (uint8_t *) calloc(out_len, sizeof(char));
274 if (buffer_out == NULL) {
275 LOGERR("Failed to allocate output buffer for try decrypt.\n");
276 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500277 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600278 return -1;
279 }
280 if (oaes_decrypt(ctx, buffer, read_len, buffer_out, &out_len) != OAES_RET_SUCCESS) {
281 LOGERR("Failed to decrypt file '%s'\n", fn.c_str());
282 fclose(f);
283 free(buffer_out);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500284 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600285 return 0;
286 }
287 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500288 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600289 if (out_len < 2) {
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500290 LOGINFO("Successfully decrypted '%s' but read length too small.\n", fn.c_str());
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600291 free(buffer_out);
292 return 1; // Decrypted successfully
293 }
294 ptr = buffer_out;
295 firstbyte = *ptr & 0xff;
296 ptr++;
297 secondbyte = *ptr & 0xff;
298 if (firstbyte == 0x1f && secondbyte == 0x8b) {
299 LOGINFO("Successfully decrypted '%s' and file is compressed.\n", fn.c_str());
300 free(buffer_out);
301 return 3; // Compressed
302 }
303 if (out_len >= 262) {
304 ptr = buffer_out + 257;
305 if (strncmp((char*)ptr, "ustar", 5) == 0) {
306 LOGINFO("Successfully decrypted '%s' and file is tar format.\n", fn.c_str());
307 free(buffer_out);
308 return 2; // Tar
309 }
310 }
311 free(buffer_out);
312 LOGINFO("No errors decrypting '%s' but no known file format.\n", fn.c_str());
313 return 1; // Decrypted successfully
314#else
315 LOGERR("Encrypted backup support not included.\n");
316 return -1;
317#endif
318}
319
Ethan Yonker472f5062016-02-25 13:47:30 -0600320unsigned long TWFunc::Get_File_Size(const string& Path) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600321 struct stat st;
322
323 if (stat(Path.c_str(), &st) != 0)
324 return 0;
325 return st.st_size;
326}
327
bigbiffee7b7ff2020-03-23 15:08:27 -0400328std::string TWFunc::Remove_Beginning_Slash(const std::string& path) {
329 std::string res;
330 size_t pos = path.find_first_of("/");
331 if (pos != std::string::npos) {
332 res = path.substr(pos+1);
333 }
334 return res;
335}
336
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100337std::string TWFunc::Remove_Trailing_Slashes(const std::string& path, bool leaveLast)
338{
339 std::string res;
340 size_t last_idx = 0, idx = 0;
341
Matt Mowera8a89d12016-12-30 18:10:37 -0600342 while (last_idx != std::string::npos)
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100343 {
Matt Mowera8a89d12016-12-30 18:10:37 -0600344 if (last_idx != 0)
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100345 res += '/';
346
347 idx = path.find_first_of('/', last_idx);
Matt Mowera8a89d12016-12-30 18:10:37 -0600348 if (idx == std::string::npos) {
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100349 res += path.substr(last_idx, idx);
350 break;
351 }
352
353 res += path.substr(last_idx, idx-last_idx);
354 last_idx = path.find_first_not_of('/', idx);
355 }
356
Matt Mowera8a89d12016-12-30 18:10:37 -0600357 if (leaveLast)
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100358 res += '/';
359 return res;
360}
361
Matt Mower2416a502016-04-12 19:54:46 -0500362void TWFunc::Strip_Quotes(char* &str) {
363 if (strlen(str) > 0 && str[0] == '\"')
364 str++;
365 if (strlen(str) > 0 && str[strlen(str)-1] == '\"')
366 str[strlen(str)-1] = 0;
367}
368
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500369vector<string> TWFunc::split_string(const string &in, char del, bool skip_empty) {
370 vector<string> res;
371
372 if (in.empty() || del == '\0')
373 return res;
374
375 string field;
376 istringstream f(in);
377 if (del == '\n') {
Matt Mowera8a89d12016-12-30 18:10:37 -0600378 while (getline(f, field)) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500379 if (field.empty() && skip_empty)
380 continue;
Matt Mowera8a89d12016-12-30 18:10:37 -0600381 res.push_back(field);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500382 }
383 } else {
Matt Mowera8a89d12016-12-30 18:10:37 -0600384 while (getline(f, field, del)) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500385 if (field.empty() && skip_empty)
386 continue;
387 res.push_back(field);
388 }
389 }
390 return res;
391}
392
Ethan Yonker472f5062016-02-25 13:47:30 -0600393timespec TWFunc::timespec_diff(timespec& start, timespec& end)
394{
395 timespec temp;
396 if ((end.tv_nsec-start.tv_nsec)<0) {
397 temp.tv_sec = end.tv_sec-start.tv_sec-1;
398 temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
399 } else {
400 temp.tv_sec = end.tv_sec-start.tv_sec;
401 temp.tv_nsec = end.tv_nsec-start.tv_nsec;
402 }
403 return temp;
404}
405
406int32_t TWFunc::timespec_diff_ms(timespec& start, timespec& end)
407{
408 return ((end.tv_sec * 1000) + end.tv_nsec/1000000) -
409 ((start.tv_sec * 1000) + start.tv_nsec/1000000);
410}
411
Adithya Ra327aa72021-12-19 00:49:54 +0530412bool TWFunc::Wait_For_File(const string& path, std::chrono::nanoseconds timeout) {
413 android::base::Timer t;
414 while (t.duration() < timeout) {
415 struct stat sb;
416 if (stat(path.c_str(), &sb) != -1) {
417 return true;
418 }
419 std::this_thread::sleep_for(10ms);
420 }
421 return false;
422}
423
424bool TWFunc::Wait_For_Battery(std::chrono::nanoseconds timeout) {
425 std::string battery_path;
426#ifdef TW_CUSTOM_BATTERY_PATH
427 battery_path = EXPAND(TW_CUSTOM_BATTERY_PATH);
428#else
429 battery_path = "/sys/class/power_supply/battery";
430#endif
431 if (!battery_path.empty()) return TWFunc::Wait_For_File(battery_path, timeout);
432
433 return false;
434}
435
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600436#ifndef BUILD_TWRPTAR_MAIN
437
Dees_Troy38bd7602012-09-14 13:33:53 -0400438// Returns "/path" from a full /path/to/file.name
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600439string TWFunc::Get_Root_Path(const string& Path) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400440 string Local_Path = Path;
441
442 // Make sure that we have a leading slash
443 if (Local_Path.substr(0, 1) != "/")
444 Local_Path = "/" + Local_Path;
445
446 // Trim the path to get the root path only
447 size_t position = Local_Path.find("/", 2);
448 if (position != string::npos) {
449 Local_Path.resize(position);
450 }
451 return Local_Path;
452}
453
Dees_Troy43d8b002012-09-17 16:00:01 -0400454int TWFunc::Recursive_Mkdir(string Path) {
thatf1408b32016-01-03 11:09:15 +0100455 std::vector<std::string> parts = Split_String(Path, "/", true);
456 std::string cur_path;
457 for (size_t i = 0; i < parts.size(); ++i) {
458 cur_path += "/" + parts[i];
459 if (!TWFunc::Path_Exists(cur_path)) {
460 if (mkdir(cur_path.c_str(), 0777)) {
Matt Mower3c366972015-12-25 19:28:31 -0600461 gui_msg(Msg(msg::kError, "create_folder_strerr=Can not create '{1}' folder ({2}).")(cur_path)(strerror(errno)));
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600462 return false;
463 } else {
thatf1408b32016-01-03 11:09:15 +0100464 tw_set_default_metadata(cur_path.c_str());
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600465 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400466 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400467 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400468 return true;
469}
470
Dees_Troyb46a6842012-09-25 11:06:46 -0400471void TWFunc::GUI_Operation_Text(string Read_Value, string Default_Text) {
472 string Display_Text;
473
474 DataManager::GetValue(Read_Value, Display_Text);
475 if (Display_Text.empty())
476 Display_Text = Default_Text;
477
478 DataManager::SetValue("tw_operation", Display_Text);
479 DataManager::SetValue("tw_partition", "");
480}
481
482void TWFunc::GUI_Operation_Text(string Read_Value, string Partition_Name, string Default_Text) {
483 string Display_Text;
484
485 DataManager::GetValue(Read_Value, Display_Text);
486 if (Display_Text.empty())
487 Display_Text = Default_Text;
488
489 DataManager::SetValue("tw_operation", Display_Text);
490 DataManager::SetValue("tw_partition", Partition_Name);
Dees_Troy7c2dec82012-09-26 09:49:14 -0400491}
492
Dees_Troy2673cec2013-04-02 20:22:16 +0000493void TWFunc::Copy_Log(string Source, string Destination) {
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400494 int logPipe[2];
495 int pigz_pid;
496 int destination_fd;
497 std::string destLogBuffer;
498
Dees Troy9d7fdf52013-09-19 20:49:25 +0000499 PartitionManager.Mount_By_Path(Destination, false);
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400500
501 size_t extPos = Destination.find(".gz");
502 std::string uncompressedLog(Destination);
503 uncompressedLog.replace(extPos, Destination.length(), "");
504
505 if (Path_Exists(Destination)) {
506 Archive_Type type = Get_File_Type(Destination);
507 if (type == COMPRESSED) {
508 std::string destFileBuffer;
509 std::string getCompressedContents = "pigz -c -d " + Destination;
bigbiffad58e1b2020-07-06 20:24:34 -0400510 if (Exec_Cmd(getCompressedContents, destFileBuffer, false) < 0) {
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400511 LOGINFO("Unable to get destination logfile contents.\n");
512 return;
513 }
514 destLogBuffer.append(destFileBuffer);
Dees_Troy6ef66352013-02-21 08:26:57 -0600515 }
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400516 } else if (Path_Exists(uncompressedLog)) {
bigbiffd3317052019-12-22 16:05:12 -0500517 std::ifstream uncompressedIfs(uncompressedLog.c_str());
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400518 std::stringstream uncompressedSS;
519 uncompressedSS << uncompressedIfs.rdbuf();
520 uncompressedIfs.close();
521 std::string uncompressedLogBuffer(uncompressedSS.str());
522 destLogBuffer.append(uncompressedLogBuffer);
523 std::remove(uncompressedLog.c_str());
Dees_Troy6ef66352013-02-21 08:26:57 -0600524 }
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400525
bigbiffd3317052019-12-22 16:05:12 -0500526 std::ifstream ifs(Source.c_str());
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400527 std::stringstream ss;
528 ss << ifs.rdbuf();
529 std::string srcLogBuffer(ss.str());
530 ifs.close();
531
532 if (pipe(logPipe) < 0) {
533 LOGINFO("Unable to open pipe to write to persistent log file: %s\n", Destination.c_str());
534 }
535
536 destination_fd = open(Destination.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
537
538 pigz_pid = fork();
539 if (pigz_pid < 0) {
540 LOGINFO("fork() failed\n");
541 close(destination_fd);
542 close(logPipe[0]);
543 close(logPipe[1]);
544 } else if (pigz_pid == 0) {
545 close(logPipe[1]);
546 dup2(logPipe[0], fileno(stdin));
547 dup2(destination_fd, fileno(stdout));
548 if (execlp("pigz", "pigz", "-", NULL) < 0) {
549 close(destination_fd);
550 close(logPipe[0]);
551 _exit(-1);
552 }
553 } else {
554 close(logPipe[0]);
555 if (write(logPipe[1], destLogBuffer.c_str(), destLogBuffer.size()) < 0) {
556 LOGINFO("Unable to append to persistent log: %s\n", Destination.c_str());
557 close(logPipe[1]);
558 close(destination_fd);
559 return;
560 }
561 if (write(logPipe[1], srcLogBuffer.c_str(), srcLogBuffer.size()) < 0) {
562 LOGINFO("Unable to append to persistent log: %s\n", Destination.c_str());
563 close(logPipe[1]);
564 close(destination_fd);
565 return;
566 }
567 close(logPipe[1]);
568 }
569 close(destination_fd);
Dees_Troya58bead2012-09-27 09:49:29 -0400570}
571
Dees_Troy2673cec2013-04-02 20:22:16 +0000572void TWFunc::Update_Log_File(void) {
bigbiff25d25b92020-06-19 16:07:38 -0400573 std::string recoveryDir = get_log_dir() + "recovery/";
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500574
bigbiff25d25b92020-06-19 16:07:38 -0400575 if (get_log_dir() == CACHE_LOGS_DIR) {
576 if (!PartitionManager.Mount_By_Path(CACHE_LOGS_DIR, false)) {
577 LOGINFO("Failed to mount %s for TWFunc::Update_Log_File\n", CACHE_LOGS_DIR);
Dees Troy9d7fdf52013-09-19 20:49:25 +0000578 }
Dees Troy9d7fdf52013-09-19 20:49:25 +0000579 }
Dees_Troya58bead2012-09-27 09:49:29 -0400580
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500581 if (!TWFunc::Path_Exists(recoveryDir)) {
582 LOGINFO("Recreating %s folder.\n", recoveryDir.c_str());
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -0400583 if (!Create_Dir_Recursive(recoveryDir, S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP, 0, 0)) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500584 LOGINFO("Unable to create %s folder.\n", recoveryDir.c_str());
585 }
586 }
587
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400588 std::string logCopy = recoveryDir + "log.gz";
589 std::string lastLogCopy = recoveryDir + "last_log.gz";
Ethan Yonker5f3b8f02021-08-16 15:10:10 -0500590 copy_file(logCopy, lastLogCopy, 0600);
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500591 Copy_Log(TMP_LOG_FILE, logCopy);
592 chown(logCopy.c_str(), 1000, 1000);
593 chmod(logCopy.c_str(), 0600);
594 chmod(lastLogCopy.c_str(), 0640);
595
bigbiff25d25b92020-06-19 16:07:38 -0400596 if (get_log_dir() == CACHE_LOGS_DIR) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500597 if (PartitionManager.Mount_By_Path("/cache", false)) {
598 if (unlink("/cache/recovery/command") && errno != ENOENT) {
599 LOGINFO("Can't unlink %s\n", "/cache/recovery/command");
600 }
Dees Troy9d7fdf52013-09-19 20:49:25 +0000601 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500602 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000603 sync();
604}
605
bigbiffdf8436b2020-08-30 16:22:34 -0400606void TWFunc::Clear_Bootloader_Message() {
607 std::string err;
608 if (!clear_bootloader_message(&err)) {
Ian Macdonaldd4851822020-11-02 08:52:32 +0100609 LOGINFO("%s\n", err.c_str());
bigbiffdf8436b2020-08-30 16:22:34 -0400610 }
611}
612
Dees_Troy2673cec2013-04-02 20:22:16 +0000613void TWFunc::Update_Intent_File(string Intent) {
614 if (PartitionManager.Mount_By_Path("/cache", false) && !Intent.empty()) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600615 TWFunc::write_to_file("/cache/recovery/intent", Intent);
Dees_Troy2673cec2013-04-02 20:22:16 +0000616 }
Dees_Troya58bead2012-09-27 09:49:29 -0400617}
618
619// reboot: Reboot the system. Return -1 on error, no return on success
620int TWFunc::tw_reboot(RebootCommand command)
621{
Ethan Yonkerfe916112016-03-14 14:54:37 -0500622 DataManager::Flush();
bigbiff25d25b92020-06-19 16:07:38 -0400623 Update_Log_File();
624
Dees_Troya58bead2012-09-27 09:49:29 -0400625 // Always force a sync before we reboot
Dees_Troy6ef66352013-02-21 08:26:57 -0600626 sync();
Dees_Troya58bead2012-09-27 09:49:29 -0400627
Dees_Troy2673cec2013-04-02 20:22:16 +0000628 switch (command) {
629 case rb_current:
630 case rb_system:
Dees_Troy2673cec2013-04-02 20:22:16 +0000631 Update_Intent_File("s");
632 sync();
bigbiffad58e1b2020-07-06 20:24:34 -0400633 check_and_run_script("/system/bin/rebootsystem.sh", "reboot system");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500634#ifdef ANDROID_RB_PROPERTY
635 return property_set(ANDROID_RB_PROPERTY, "reboot,");
636#elif defined(ANDROID_RB_RESTART)
637 return android_reboot(ANDROID_RB_RESTART, 0, 0);
638#else
Dees_Troy2673cec2013-04-02 20:22:16 +0000639 return reboot(RB_AUTOBOOT);
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500640#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000641 case rb_recovery:
bigbiffad58e1b2020-07-06 20:24:34 -0400642 check_and_run_script("/system/bin/rebootrecovery.sh", "reboot recovery");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500643 return property_set(ANDROID_RB_PROPERTY, "reboot,recovery");
Dees_Troy2673cec2013-04-02 20:22:16 +0000644 case rb_bootloader:
bigbiffad58e1b2020-07-06 20:24:34 -0400645 check_and_run_script("/system/bin/rebootbootloader.sh", "reboot bootloader");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500646 return property_set(ANDROID_RB_PROPERTY, "reboot,bootloader");
Dees_Troy2673cec2013-04-02 20:22:16 +0000647 case rb_poweroff:
bigbiffad58e1b2020-07-06 20:24:34 -0400648 check_and_run_script("/system/bin/poweroff.sh", "power off");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500649#ifdef ANDROID_RB_PROPERTY
650 return property_set(ANDROID_RB_PROPERTY, "shutdown,");
651#elif defined(ANDROID_RB_POWEROFF)
652 return android_reboot(ANDROID_RB_POWEROFF, 0, 0);
653#else
Dees_Troy2673cec2013-04-02 20:22:16 +0000654 return reboot(RB_POWER_OFF);
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500655#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000656 case rb_download:
bigbiffad58e1b2020-07-06 20:24:34 -0400657 check_and_run_script("/system/bin/rebootdownload.sh", "reboot download");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500658 return property_set(ANDROID_RB_PROPERTY, "reboot,download");
mauronofrioe9a49ef2018-10-03 13:38:16 +0200659 case rb_edl:
bigbiffad58e1b2020-07-06 20:24:34 -0400660 check_and_run_script("/system/bin/rebootedl.sh", "reboot edl");
mauronofrioe9a49ef2018-10-03 13:38:16 +0200661 return property_set(ANDROID_RB_PROPERTY, "reboot,edl");
bigbiffdf8436b2020-08-30 16:22:34 -0400662 case rb_fastboot:
663 return property_set(ANDROID_RB_PROPERTY, "reboot,fastboot");
Dees_Troy2673cec2013-04-02 20:22:16 +0000664 default:
665 return -1;
Dees_Troy6ef66352013-02-21 08:26:57 -0600666 }
667 return -1;
Dees_Troya58bead2012-09-27 09:49:29 -0400668}
669
670void TWFunc::check_and_run_script(const char* script_file, const char* display_name)
671{
672 // Check for and run startup script if script exists
673 struct stat st;
674 if (stat(script_file, &st) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500675 gui_msg(Msg("run_script=Running {1} script...")(display_name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500676 chmod(script_file, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
Vojtech Bocek05534202013-09-11 08:11:56 +0200677 TWFunc::Exec_Cmd(script_file);
Ethan Yonker74db1572015-10-28 12:44:49 -0500678 gui_msg("done=Done.");
Dees_Troya58bead2012-09-27 09:49:29 -0400679 }
Dees_Troy3477d712012-09-27 15:44:01 -0400680}
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500681
682int TWFunc::removeDir(const string path, bool skipParent) {
Dees_Troyce675462013-01-09 19:48:21 +0000683 DIR *d = opendir(path.c_str());
684 int r = 0;
685 string new_path;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500686
Dees_Troyce675462013-01-09 19:48:21 +0000687 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500688 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(path)(strerror(errno)));
Dees_Troyce675462013-01-09 19:48:21 +0000689 return -1;
690 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500691
Dees_Troyce675462013-01-09 19:48:21 +0000692 if (d) {
693 struct dirent *p;
694 while (!r && (p = readdir(d))) {
Dees_Troyce675462013-01-09 19:48:21 +0000695 if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
696 continue;
697 new_path = path + "/";
698 new_path.append(p->d_name);
699 if (p->d_type == DT_DIR) {
700 r = removeDir(new_path, true);
701 if (!r) {
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500702 if (p->d_type == DT_DIR)
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500703 r = rmdir(new_path.c_str());
704 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000705 LOGINFO("Unable to removeDir '%s': %s\n", new_path.c_str(), strerror(errno));
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500706 }
bigbiff bigbiff98f1f902013-01-19 18:46:13 -0500707 } else if (p->d_type == DT_REG || p->d_type == DT_LNK || p->d_type == DT_FIFO || p->d_type == DT_SOCK) {
Dees_Troyce675462013-01-09 19:48:21 +0000708 r = unlink(new_path.c_str());
Dees_Troye34c1332013-02-06 19:13:00 +0000709 if (r != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000710 LOGINFO("Unable to unlink '%s: %s'\n", new_path.c_str(), strerror(errno));
Dees_Troye34c1332013-02-06 19:13:00 +0000711 }
Dees_Troyce675462013-01-09 19:48:21 +0000712 }
713 }
714 closedir(d);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500715
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500716 if (!r) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500717 if (skipParent)
718 return 0;
719 else
720 r = rmdir(path.c_str());
721 }
Dees_Troyce675462013-01-09 19:48:21 +0000722 }
723 return r;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500724}
725
bigbiff22851b92021-09-01 16:46:57 -0400726int TWFunc::copy_file(string src, string dst, int mode, bool mount_paths) {
727 if (mount_paths) {
728 PartitionManager.Mount_By_Path(src, false);
729 PartitionManager.Mount_By_Path(dst, false);
730 }
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400731 if (!Path_Exists(src)) {
bigbiff22851b92021-09-01 16:46:57 -0400732 LOGINFO("Path %s does not exist. Unable to copy file to %s\n", src.c_str(), dst.c_str());
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400733 return -1;
734 }
bigbiffd3317052019-12-22 16:05:12 -0500735 std::ifstream srcfile(src.c_str(), ios::binary);
736 std::ofstream dstfile(dst.c_str(), ios::binary);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500737 dstfile << srcfile.rdbuf();
bigbiff850fa282021-10-09 12:37:29 -0400738 if (dstfile.bad()) {
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400739 LOGINFO("Unable to copy file %s to %s\n", src.c_str(), dst.c_str());
740 return -1;
741 }
742
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500743 srcfile.close();
744 dstfile.close();
bigbiff22851b92021-09-01 16:46:57 -0400745 if (chmod(dst.c_str(), mode) != 0) {
746 LOGERR("Unable to chmod file: %s. Error: %s\n", dst.c_str(), strerror(errno));
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500747 return -1;
bigbiff22851b92021-09-01 16:46:57 -0400748 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500749 return 0;
750}
Dees_Troy3ee47bc2013-01-25 21:47:37 +0000751
752unsigned int TWFunc::Get_D_Type_From_Stat(string Path) {
753 struct stat st;
754
755 stat(Path.c_str(), &st);
756 if (st.st_mode & S_IFDIR)
757 return DT_DIR;
758 else if (st.st_mode & S_IFBLK)
759 return DT_BLK;
760 else if (st.st_mode & S_IFCHR)
761 return DT_CHR;
762 else if (st.st_mode & S_IFIFO)
763 return DT_FIFO;
764 else if (st.st_mode & S_IFLNK)
765 return DT_LNK;
766 else if (st.st_mode & S_IFREG)
767 return DT_REG;
768 else if (st.st_mode & S_IFSOCK)
769 return DT_SOCK;
770 return DT_UNKNOWN;
Dees_Troye34c1332013-02-06 19:13:00 +0000771}
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500772
773int TWFunc::read_file(string fn, string& results) {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200774 ifstream file;
775 file.open(fn.c_str(), ios::in);
776
777 if (file.is_open()) {
bigbiff22851b92021-09-01 16:46:57 -0400778 std::string line;
779 while (std::getline(file, line)) {
780 results += line;
781 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200782 file.close();
783 return 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500784 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200785
786 LOGINFO("Cannot find file %s\n", fn.c_str());
787 return -1;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500788}
789
790int TWFunc::read_file(string fn, vector<string>& results) {
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500791 ifstream file;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500792 string line;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500793 file.open(fn.c_str(), ios::in);
794 if (file.is_open()) {
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500795 while (getline(file, line))
796 results.push_back(line);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500797 file.close();
798 return 0;
799 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000800 LOGINFO("Cannot find file %s\n", fn.c_str());
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500801 return -1;
802}
803
xNUTxe85f02d2014-07-18 01:30:58 +0200804int TWFunc::read_file(string fn, uint64_t& results) {
805 ifstream file;
806 file.open(fn.c_str(), ios::in);
807
808 if (file.is_open()) {
809 file >> results;
810 file.close();
811 return 0;
812 }
813
814 LOGINFO("Cannot find file %s\n", fn.c_str());
815 return -1;
816}
817
bigbiff22851b92021-09-01 16:46:57 -0400818bool TWFunc::write_to_file(const string& fn, const string& line) {
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500819 FILE *file;
820 file = fopen(fn.c_str(), "w");
821 if (file != NULL) {
822 fwrite(line.c_str(), line.size(), 1, file);
823 fclose(file);
bigbiff22851b92021-09-01 16:46:57 -0400824 return true;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500825 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000826 LOGINFO("Cannot find file %s\n", fn.c_str());
bigbiff22851b92021-09-01 16:46:57 -0400827 return false;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500828}
829
bigbiff22851b92021-09-01 16:46:57 -0400830bool TWFunc::write_to_file(const string& fn, const std::vector<string> lines) {
831 FILE *file;
832 file = fopen(fn.c_str(), "a+");
833 if (file != NULL) {
834 for (auto&& line: lines) {
835 fwrite(line.c_str(), line.size(), 1, file);
836 fwrite("\n", sizeof(char), 1, file);
837 }
838 fclose(file);
839 return true;
840 }
841 return false;
842}
843
844
Dees_Troy83bd4832013-05-04 12:39:56 +0000845bool TWFunc::Try_Decrypting_Backup(string Restore_Path, string Password) {
846 DIR* d;
847
848 string Filename;
849 Restore_Path += "/";
850 d = opendir(Restore_Path.c_str());
851 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500852 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Path)(strerror(errno)));
Dees_Troy83bd4832013-05-04 12:39:56 +0000853 return false;
854 }
855
856 struct dirent* de;
857 while ((de = readdir(d)) != NULL) {
858 Filename = Restore_Path;
859 Filename += de->d_name;
bigbiffce8f83c2015-12-12 18:30:21 -0500860 if (TWFunc::Get_File_Type(Filename) == ENCRYPTED) {
Dees_Troy83bd4832013-05-04 12:39:56 +0000861 if (TWFunc::Try_Decrypting_File(Filename, Password) < 2) {
862 DataManager::SetValue("tw_restore_password", ""); // Clear the bad password
863 DataManager::SetValue("tw_restore_display", ""); // Also clear the display mask
864 closedir(d);
865 return false;
866 }
867 }
868 }
869 closedir(d);
870 return true;
871}
872
Dees Troyb21cc642013-09-10 17:36:41 +0000873string TWFunc::Get_Current_Date() {
874 string Current_Date;
875 time_t seconds = time(0);
876 struct tm *t = localtime(&seconds);
877 char timestamp[255];
878 sprintf(timestamp,"%04d-%02d-%02d--%02d-%02d-%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec);
879 Current_Date = timestamp;
880 return Current_Date;
881}
882
Ethan Yonkerb5557892014-02-07 21:43:20 -0600883string TWFunc::System_Property_Get(string Prop_Name) {
Captain Throwback12608c32022-01-05 18:58:19 -0500884 return System_Property_Get(Prop_Name, PartitionManager, PartitionManager.Get_Android_Root_Path(), "build.prop");
Chaosmaster65633a42020-02-05 15:24:09 +0100885}
886
Captain Throwback2b9ea722021-12-31 21:35:52 -0500887string TWFunc::System_Property_Get(string Prop_Name, TWPartitionManager &PartitionManager, string Mount_Point, string prop_file_name) {
Chaosmaster65633a42020-02-05 15:24:09 +0100888 bool mount_state = PartitionManager.Is_Mounted_By_Path(Mount_Point);
Dees Troyb21cc642013-09-10 17:36:41 +0000889 std::vector<string> buildprop;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600890 string propvalue;
Chaosmaster65633a42020-02-05 15:24:09 +0100891 if (!PartitionManager.Mount_By_Path(Mount_Point, true))
Ethan Yonkerb5557892014-02-07 21:43:20 -0600892 return propvalue;
Captain Throwback2b9ea722021-12-31 21:35:52 -0500893 string prop_file = Mount_Point + "/system/" + prop_file_name;
894 if (!TWFunc::Path_Exists(prop_file)) {
895 LOGINFO("Unable to locate file: %s\n", prop_file.c_str());
896 return propvalue;
897 }
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600898 if (TWFunc::read_file(prop_file, buildprop) != 0) {
Captain Throwback2b9ea722021-12-31 21:35:52 -0500899 LOGINFO("Unable to open %s for getting '%s'.\n", prop_file_name.c_str(), Prop_Name.c_str());
Vojtech Boceka2e70162013-09-17 17:05:10 +0200900 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
Dees Troyb21cc642013-09-10 17:36:41 +0000901 if (!mount_state)
Chaosmaster65633a42020-02-05 15:24:09 +0100902 PartitionManager.UnMount_By_Path(Mount_Point, false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600903 return propvalue;
Dees Troyb21cc642013-09-10 17:36:41 +0000904 }
905 int line_count = buildprop.size();
906 int index;
907 size_t start_pos = 0, end_pos;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600908 string propname;
Dees Troyb21cc642013-09-10 17:36:41 +0000909 for (index = 0; index < line_count; index++) {
910 end_pos = buildprop.at(index).find("=", start_pos);
911 propname = buildprop.at(index).substr(start_pos, end_pos);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600912 if (propname == Prop_Name) {
Dees Troyb21cc642013-09-10 17:36:41 +0000913 propvalue = buildprop.at(index).substr(end_pos + 1, buildprop.at(index).size());
Ethan Yonkerb5557892014-02-07 21:43:20 -0600914 if (!mount_state)
Chaosmaster65633a42020-02-05 15:24:09 +0100915 PartitionManager.UnMount_By_Path(Mount_Point, false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600916 return propvalue;
Dees Troyb21cc642013-09-10 17:36:41 +0000917 }
918 }
Dees Troyb21cc642013-09-10 17:36:41 +0000919 if (!mount_state)
Chaosmaster65633a42020-02-05 15:24:09 +0100920 PartitionManager.UnMount_By_Path(Mount_Point, false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600921 return propvalue;
922}
923
924void TWFunc::Auto_Generate_Backup_Name() {
925 string propvalue = System_Property_Get("ro.build.display.id");
926 if (propvalue.empty()) {
927 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
928 return;
929 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400930 else {
931 //remove periods from build display so it doesn't confuse the extension code
932 propvalue.erase(remove(propvalue.begin(), propvalue.end(), '.'), propvalue.end());
933 }
Ethan Yonkerb5557892014-02-07 21:43:20 -0600934 string Backup_Name = Get_Current_Date();
bigbiff74a6d0d2015-02-14 20:49:44 -0500935 Backup_Name += "_" + propvalue;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600936 if (Backup_Name.size() > MAX_BACKUP_NAME_LEN)
937 Backup_Name.resize(MAX_BACKUP_NAME_LEN);
938 // Trailing spaces cause problems on some file systems, so remove them
939 string space_check, space = " ";
940 space_check = Backup_Name.substr(Backup_Name.size() - 1, 1);
941 while (space_check == space) {
942 Backup_Name.resize(Backup_Name.size() - 1);
943 space_check = Backup_Name.substr(Backup_Name.size() - 1, 1);
944 }
bigbiff74a6d0d2015-02-14 20:49:44 -0500945 replace(Backup_Name.begin(), Backup_Name.end(), ' ', '_');
Ethan Yonker53796e72019-01-11 22:49:52 -0600946 if (PartitionManager.Check_Backup_Name(Backup_Name, false, true) != 0) {
947 LOGINFO("Auto generated backup name '%s' is not valid, using date instead.\n", Backup_Name.c_str());
Ethan Yonker92d48e02014-02-26 12:05:55 -0600948 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
Ethan Yonker53796e72019-01-11 22:49:52 -0600949 } else {
950 DataManager::SetValue(TW_BACKUP_NAME, Backup_Name);
Ethan Yonker92d48e02014-02-26 12:05:55 -0600951 }
Vojtech Bocek05534202013-09-11 08:11:56 +0200952}
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100953
nkk7198fc3992017-12-16 16:26:42 +0200954void TWFunc::Fixup_Time_On_Boot(const string& time_paths /* = "" */)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100955{
956#ifdef QCOM_RTC_FIX
nkk7198fc3992017-12-16 16:26:42 +0200957 static bool fixed = false;
958 if (fixed)
959 return;
xNUTxe85f02d2014-07-18 01:30:58 +0200960
961 LOGINFO("TWFunc::Fixup_Time: Pre-fix date and time: %s\n", TWFunc::Get_Current_Date().c_str());
962
963 struct timeval tv;
964 uint64_t offset = 0;
965 std::string sepoch = "/sys/class/rtc/rtc0/since_epoch";
966
967 if (TWFunc::read_file(sepoch, offset) == 0) {
968
969 LOGINFO("TWFunc::Fixup_Time: Setting time offset from file %s\n", sepoch.c_str());
970
971 tv.tv_sec = offset;
972 tv.tv_usec = 0;
973 settimeofday(&tv, NULL);
974
975 gettimeofday(&tv, NULL);
976
Phoenix59146b05f22018-02-03 06:41:08 +0000977 if (tv.tv_sec > 1517600000) { // Anything older then 2 Feb 2018 19:33:20 GMT will do nicely thank you ;)
xNUTxe85f02d2014-07-18 01:30:58 +0200978
979 LOGINFO("TWFunc::Fixup_Time: Date and time corrected: %s\n", TWFunc::Get_Current_Date().c_str());
nkk7198fc3992017-12-16 16:26:42 +0200980 fixed = true;
xNUTxe85f02d2014-07-18 01:30:58 +0200981 return;
982
983 }
984
985 } else {
986
987 LOGINFO("TWFunc::Fixup_Time: opening %s failed\n", sepoch.c_str());
988
989 }
990
Ethan Yonker9132d912015-02-02 10:32:49 -0600991 LOGINFO("TWFunc::Fixup_Time: will attempt to use the ats files now.\n");
xNUTxe85f02d2014-07-18 01:30:58 +0200992
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100993 // Devices with Qualcomm Snapdragon 800 do some shenanigans with RTC.
994 // They never set it, it just ticks forward from 1970-01-01 00:00,
995 // and then they have files /data/system/time/ats_* with 64bit offset
996 // in miliseconds which, when added to the RTC, gives the correct time.
997 // So, the time is: (offset_from_ats + value_from_RTC)
998 // There are multiple ats files, they are for different systems? Bases?
999 // Like, ats_1 is for modem and ats_2 is for TOD (time of day?).
1000 // Look at file time_genoff.h in CodeAurora, qcom-opensource/time-services
1001
nkk7198fc3992017-12-16 16:26:42 +02001002 std::vector<std::string> paths; // space separated list of paths
1003 if (time_paths.empty()) {
Mauronofrio Matarrese2dab70d2019-03-05 02:22:26 +01001004 paths = Split_String("/data/system/time/ /data/time/ /data/vendor/time/", " ");
nkk7198fc3992017-12-16 16:26:42 +02001005 if (!PartitionManager.Mount_By_Path("/data", false))
1006 return;
1007 } else {
1008 // When specific path(s) are used, Fixup_Time needs those
1009 // partitions to already be mounted!
1010 paths = Split_String(time_paths, " ");
1011 }
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001012
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001013 FILE *f;
xNUTxe85f02d2014-07-18 01:30:58 +02001014 offset = 0;
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001015 struct dirent *dt;
1016 std::string ats_path;
1017
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001018 // Prefer ats_2, it seems to be the one we want according to logcat on hammerhead
1019 // - it is the one for ATS_TOD (time of day?).
1020 // However, I never saw a device where the offset differs between ats files.
nkk7198fc3992017-12-16 16:26:42 +02001021 for (size_t i = 0; i < paths.size(); ++i)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001022 {
nkk7198fc3992017-12-16 16:26:42 +02001023 DIR *d = opendir(paths[i].c_str());
Matt Mowera8a89d12016-12-30 18:10:37 -06001024 if (!d)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001025 continue;
1026
Matt Mowera8a89d12016-12-30 18:10:37 -06001027 while ((dt = readdir(d)))
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001028 {
Matt Mowera8a89d12016-12-30 18:10:37 -06001029 if (dt->d_type != DT_REG || strncmp(dt->d_name, "ats_", 4) != 0)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001030 continue;
1031
Matt Mowera8a89d12016-12-30 18:10:37 -06001032 if (ats_path.empty() || strcmp(dt->d_name, "ats_2") == 0)
nkk7198fc3992017-12-16 16:26:42 +02001033 ats_path = paths[i] + dt->d_name;
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001034 }
1035
1036 closedir(d);
1037 }
1038
nkk7198fc3992017-12-16 16:26:42 +02001039 if (ats_path.empty()) {
xNUTxe85f02d2014-07-18 01:30:58 +02001040 LOGINFO("TWFunc::Fixup_Time: no ats files found, leaving untouched!\n");
nkk7198fc3992017-12-16 16:26:42 +02001041 } else if ((f = fopen(ats_path.c_str(), "r")) == NULL) {
Dees Troy3e254b92014-03-06 20:24:54 +00001042 LOGINFO("TWFunc::Fixup_Time: failed to open file %s\n", ats_path.c_str());
nkk7198fc3992017-12-16 16:26:42 +02001043 } else if (fread(&offset, sizeof(offset), 1, f) != 1) {
Dees Troy3e254b92014-03-06 20:24:54 +00001044 LOGINFO("TWFunc::Fixup_Time: failed load uint64 from file %s\n", ats_path.c_str());
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001045 fclose(f);
nkk7198fc3992017-12-16 16:26:42 +02001046 } else {
1047 fclose(f);
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001048
nkk7198fc3992017-12-16 16:26:42 +02001049 LOGINFO("TWFunc::Fixup_Time: Setting time offset from file %s, offset %llu\n", ats_path.c_str(), (unsigned long long) offset);
1050 DataManager::SetValue("tw_qcom_ats_offset", (unsigned long long) offset, 1);
1051 fixed = true;
1052 }
1053
1054 if (!fixed) {
Captain Throwbackf74fc052022-01-19 13:25:54 -05001055#ifdef TW_QCOM_ATS_OFFSET
1056 // Offset is the difference between the current time and the time since_epoch
1057 // To calculate the offset in Android, the following expression (from a root shell) can be used:
1058 // echo "$(( ($(date +%s) - $(cat /sys/class/rtc/rtc0/since_epoch)) ))"
1059 // Add 3 zeros to the output and use that in the TW_QCOM_ATS_OFFSET flag in your BoardConfig.mk
1060 // For example, if the result of the calculation is 1642433544, use 1642433544000 as the offset
1061 offset = (uint64_t) TW_QCOM_ATS_OFFSET;
1062 DataManager::SetValue("tw_qcom_ats_offset", (unsigned long long) offset, 1);
1063 LOGINFO("TWFunc::Fixup_Time: Setting time offset from TW_QCOM_ATS_OFFSET, offset %llu\n", (unsigned long long) offset);
1064#else
nkk7198fc3992017-12-16 16:26:42 +02001065 // Failed to get offset from ats file, check twrp settings
1066 unsigned long long value;
1067 if (DataManager::GetValue("tw_qcom_ats_offset", value) < 0) {
1068 return;
1069 } else {
1070 offset = (uint64_t) value;
1071 LOGINFO("TWFunc::Fixup_Time: Setting time offset from twrp setting file, offset %llu\n", (unsigned long long) offset);
1072 // Do not consider the settings file as a definitive answer, keep fixed=false so next run will try ats files again
1073 }
Captain Throwbackf74fc052022-01-19 13:25:54 -05001074#endif
nkk7198fc3992017-12-16 16:26:42 +02001075 }
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001076
1077 gettimeofday(&tv, NULL);
1078
1079 tv.tv_sec += offset/1000;
Phoenix591e444d112018-02-03 07:23:54 +00001080#ifdef TW_CLOCK_OFFSET
1081// Some devices are even quirkier and have ats files that are offset from the actual time
1082 tv.tv_sec = tv.tv_sec + TW_CLOCK_OFFSET;
1083#endif
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001084 tv.tv_usec += (offset%1000)*1000;
1085
Matt Mowera8a89d12016-12-30 18:10:37 -06001086 while (tv.tv_usec >= 1000000)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001087 {
1088 ++tv.tv_sec;
1089 tv.tv_usec -= 1000000;
1090 }
1091
1092 settimeofday(&tv, NULL);
xNUTxe85f02d2014-07-18 01:30:58 +02001093
1094 LOGINFO("TWFunc::Fixup_Time: Date and time corrected: %s\n", TWFunc::Get_Current_Date().c_str());
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001095#endif
1096}
Ethan Yonkeraf2897c2014-02-10 13:07:14 -06001097
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001098std::vector<std::string> TWFunc::Split_String(const std::string& str, const std::string& delimiter, bool removeEmpty)
1099{
1100 std::vector<std::string> res;
1101 size_t idx = 0, idx_last = 0;
1102
Matt Mowera8a89d12016-12-30 18:10:37 -06001103 while (idx < str.size())
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001104 {
1105 idx = str.find_first_of(delimiter, idx_last);
Matt Mowera8a89d12016-12-30 18:10:37 -06001106 if (idx == std::string::npos)
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001107 idx = str.size();
1108
Matt Mowera8a89d12016-12-30 18:10:37 -06001109 if (idx-idx_last != 0 || !removeEmpty)
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001110 res.push_back(str.substr(idx_last, idx-idx_last));
1111
1112 idx_last = idx + delimiter.size();
1113 }
1114
1115 return res;
1116}
1117
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001118bool TWFunc::Create_Dir_Recursive(const std::string& path, mode_t mode, uid_t uid, gid_t gid)
1119{
1120 std::vector<std::string> parts = Split_String(path, "/");
1121 std::string cur_path;
1122 struct stat info;
Matt Mowera8a89d12016-12-30 18:10:37 -06001123 for (size_t i = 0; i < parts.size(); ++i)
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001124 {
1125 cur_path += "/" + parts[i];
Matt Mowera8a89d12016-12-30 18:10:37 -06001126 if (stat(cur_path.c_str(), &info) < 0 || !S_ISDIR(info.st_mode))
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001127 {
Matt Mowera8a89d12016-12-30 18:10:37 -06001128 if (mkdir(cur_path.c_str(), mode) < 0)
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001129 return false;
1130 chown(cur_path.c_str(), uid, gid);
1131 }
1132 }
1133 return true;
1134}
1135
xNUTxe85f02d2014-07-18 01:30:58 +02001136int TWFunc::Set_Brightness(std::string brightness_value)
1137{
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001138 int result = -1;
1139 std::string secondary_brightness_file;
xNUTxe85f02d2014-07-18 01:30:58 +02001140
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001141 if (DataManager::GetIntValue("tw_has_brightnesss_file")) {
xNUTxe85f02d2014-07-18 01:30:58 +02001142 LOGINFO("TWFunc::Set_Brightness: Setting brightness control to %s\n", brightness_value.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001143 result = TWFunc::write_to_file(DataManager::GetStrValue("tw_brightness_file"), brightness_value);
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001144 DataManager::GetValue("tw_secondary_brightness_file", secondary_brightness_file);
1145 if (!secondary_brightness_file.empty()) {
1146 LOGINFO("TWFunc::Set_Brightness: Setting secondary brightness control to %s\n", brightness_value.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001147 TWFunc::write_to_file(secondary_brightness_file, brightness_value);
xNUTxe85f02d2014-07-18 01:30:58 +02001148 }
xNUTxe85f02d2014-07-18 01:30:58 +02001149 }
bigbiff22851b92021-09-01 16:46:57 -04001150 return result ? 0 : -1;
xNUTxe85f02d2014-07-18 01:30:58 +02001151}
1152
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001153bool TWFunc::Toggle_MTP(bool enable) {
1154#ifdef TW_HAS_MTP
1155 static int was_enabled = false;
1156
1157 if (enable && was_enabled) {
1158 if (!PartitionManager.Enable_MTP())
1159 PartitionManager.Disable_MTP();
1160 } else {
1161 was_enabled = DataManager::GetIntValue("tw_mtp_enabled");
1162 PartitionManager.Disable_MTP();
1163 usleep(500);
1164 }
1165 return was_enabled;
1166#else
1167 return false;
1168#endif
1169}
1170
Tom Hite5a926722014-09-15 01:31:03 +00001171void TWFunc::SetPerformanceMode(bool mode) {
1172 if (mode) {
1173 property_set("recovery.perf.mode", "1");
1174 } else {
1175 property_set("recovery.perf.mode", "0");
1176 }
1177 // Some time for events to catch up to init handlers
1178 usleep(500000);
1179}
1180
Jenkins1710bf22014-10-02 20:22:21 -04001181std::string TWFunc::to_string(unsigned long value) {
1182 std::ostringstream os;
1183 os << value;
1184 return os.str();
1185}
1186
Ethan Yonker9132d912015-02-02 10:32:49 -06001187void TWFunc::Disable_Stock_Recovery_Replace(void) {
Captain Throwback9d6feb52018-07-27 10:05:24 -04001188 if (PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), false)) {
Ethan Yonker9132d912015-02-02 10:32:49 -06001189 // Disable flashing of stock recovery
1190 if (TWFunc::Path_Exists("/system/recovery-from-boot.p")) {
1191 rename("/system/recovery-from-boot.p", "/system/recovery-from-boot.bak");
Ethan Yonker74db1572015-10-28 12:44:49 -05001192 gui_msg("rename_stock=Renamed stock recovery file in /system to prevent the stock ROM from replacing TWRP.");
Ethan Yonker9132d912015-02-02 10:32:49 -06001193 sync();
1194 }
Captain Throwback9d6feb52018-07-27 10:05:24 -04001195 PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), false);
Ethan Yonker9132d912015-02-02 10:32:49 -06001196 }
1197}
1198
Ethan Yonker483e9f42016-01-11 22:21:18 -06001199unsigned long long TWFunc::IOCTL_Get_Block_Size(const char* block_device) {
1200 unsigned long block_device_size;
1201 int ret = 0;
1202
1203 int fd = open(block_device, O_RDONLY);
1204 if (fd < 0) {
1205 LOGINFO("Find_Partition_Size: Failed to open '%s', (%s)\n", block_device, strerror(errno));
1206 } else {
1207 ret = ioctl(fd, BLKGETSIZE, &block_device_size);
1208 close(fd);
1209 if (ret) {
1210 LOGINFO("Find_Partition_Size: ioctl error: (%s)\n", strerror(errno));
1211 } else {
1212 return (unsigned long long)(block_device_size) * 512LLU;
1213 }
1214 }
1215 return 0;
1216}
1217
bigbiff bigbiffbad332a2016-07-29 21:18:13 -04001218void TWFunc::copy_kernel_log(string curr_storage) {
1219 std::string dmesgDst = curr_storage + "/dmesg.log";
bigbiffad58e1b2020-07-06 20:24:34 -04001220 std::string dmesgCmd = "/system/bin/dmesg";
bigbiff bigbiffbad332a2016-07-29 21:18:13 -04001221
1222 std::string result;
bigbiffad58e1b2020-07-06 20:24:34 -04001223 Exec_Cmd(dmesgCmd, result, false);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001224 write_to_file(dmesgDst, result);
bigbiff bigbiffbad332a2016-07-29 21:18:13 -04001225 gui_msg(Msg("copy_kernel_log=Copied kernel log to {1}")(dmesgDst));
1226 tw_set_default_metadata(dmesgDst.c_str());
1227}
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001228
Captain Throwback52978932021-09-05 15:11:07 -04001229void TWFunc::copy_logcat(string curr_storage) {
1230 std::string logcatDst = curr_storage + "/logcat.txt";
1231 std::string logcatCmd = "logcat -d";
1232
1233 std::string result;
1234 Exec_Cmd(logcatCmd, result, false);
1235 write_to_file(logcatDst, result);
1236 gui_msg(Msg("copy_logcat=Copied logcat to {1}")(logcatDst));
1237 tw_set_default_metadata(logcatDst.c_str());
1238}
1239
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001240bool TWFunc::isNumber(string strtocheck) {
1241 int num = 0;
1242 std::istringstream iss(strtocheck);
1243
1244 if (!(iss >> num).fail())
1245 return true;
1246 else
1247 return false;
1248}
1249
1250int TWFunc::stream_adb_backup(string &Restore_Name) {
bigbiffad58e1b2020-07-06 20:24:34 -04001251 string cmd = "/system/bin/bu --twrp stream " + Restore_Name;
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001252 LOGINFO("stream_adb_backup: %s\n", cmd.c_str());
1253 int ret = TWFunc::Exec_Cmd(cmd);
1254 if (ret != 0)
1255 return -1;
1256 return ret;
1257}
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001258
bigbiff25d25b92020-06-19 16:07:38 -04001259std::string TWFunc::get_log_dir() {
1260 if (PartitionManager.Find_Partition_By_Path(CACHE_LOGS_DIR) == NULL) {
1261 if (PartitionManager.Find_Partition_By_Path(DATA_LOGS_DIR) == NULL) {
bigbiffaac58612020-08-30 11:18:39 -04001262 LOGINFO("Unable to find a directory to store TWRP logs.");
1263 return "";
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -04001264 } else {
bigbiff25d25b92020-06-19 16:07:38 -04001265 return DATA_LOGS_DIR;
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -04001266 }
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001267 }
1268 else {
bigbiff25d25b92020-06-19 16:07:38 -04001269 return CACHE_LOGS_DIR;
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001270 }
1271}
1272
1273void TWFunc::check_selinux_support() {
1274 if (TWFunc::Path_Exists("/prebuilt_file_contexts")) {
1275 if (TWFunc::Path_Exists("/file_contexts")) {
1276 printf("Renaming regular /file_contexts -> /file_contexts.bak\n");
1277 rename("/file_contexts", "/file_contexts.bak");
1278 }
1279 printf("Moving /prebuilt_file_contexts -> /file_contexts\n");
1280 rename("/prebuilt_file_contexts", "/file_contexts");
1281 }
1282 struct selinux_opt selinux_options[] = {
1283 { SELABEL_OPT_PATH, "/file_contexts" }
1284 };
1285 selinux_handle = selabel_open(SELABEL_CTX_FILE, selinux_options, 1);
1286 if (!selinux_handle)
1287 printf("No file contexts for SELinux\n");
1288 else
1289 printf("SELinux contexts loaded from /file_contexts\n");
1290 { // Check to ensure SELinux can be supported by the kernel
1291 char *contexts = NULL;
bigbiff25d25b92020-06-19 16:07:38 -04001292 std::string cacheDir = TWFunc::get_log_dir();
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001293 std::string se_context_check = cacheDir + "recovery/";
1294 int ret = 0;
1295
bigbiff25d25b92020-06-19 16:07:38 -04001296 if (cacheDir == CACHE_LOGS_DIR) {
1297 PartitionManager.Mount_By_Path(CACHE_LOGS_DIR, false);
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001298 }
1299 if (TWFunc::Path_Exists(se_context_check)) {
1300 ret = lgetfilecon(se_context_check.c_str(), &contexts);
Makornthawat Emeryabc299c2019-03-29 13:45:22 +00001301 if (ret < 0) {
bigbiffad58e1b2020-07-06 20:24:34 -04001302 LOGINFO("Could not check %s SELinux contexts, using /system/bin/teamwin instead which may be inaccurate.\n", se_context_check.c_str());
1303 lgetfilecon("/system/bin/teamwin", &contexts);
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001304 }
1305 }
1306 if (ret < 0) {
1307 gui_warn("no_kernel_selinux=Kernel does not have support for reading SELinux contexts.");
1308 } else {
1309 free(contexts);
1310 gui_msg("full_selinux=Full SELinux support is present.");
1311 }
1312 }
1313}
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05001314
1315bool TWFunc::Is_TWRP_App_In_System() {
bigbiffee7b7ff2020-03-23 15:08:27 -04001316 LOGINFO("checking for twrp app\n");
1317 TWPartition* sys = PartitionManager.Find_Partition_By_Path(PartitionManager.Get_Android_Root_Path());
1318 if (!sys->Get_Super_Status()) {
Captain Throwback31c14922020-12-21 11:28:34 -05001319 bool is_system_mounted = true;
1320 if(!PartitionManager.Is_Mounted_By_Path(PartitionManager.Get_Android_Root_Path())) {
1321 is_system_mounted = false;
1322 PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), false);
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05001323 }
Captain Throwback31c14922020-12-21 11:28:34 -05001324 string base_path = PartitionManager.Get_Android_Root_Path();
1325 if (TWFunc::Path_Exists(PartitionManager.Get_Android_Root_Path() + "/system"))
1326 base_path += "/system"; // For devices with system as a root file system (e.g. Pixel)
1327 string install_path = base_path + "/priv-app";
1328 if (!TWFunc::Path_Exists(install_path))
1329 install_path = base_path + "/app";
1330 install_path += "/twrpapp";
1331 if (TWFunc::Path_Exists(install_path)) {
1332 LOGINFO("App found at '%s'\n", install_path.c_str());
1333 DataManager::SetValue("tw_app_installed_in_system", 1);
1334 return true;
1335 }
1336 if (!is_system_mounted)
1337 PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), false);
bigbiffee7b7ff2020-03-23 15:08:27 -04001338 DataManager::SetValue("tw_app_installed_in_system", 0);
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05001339 }
1340 DataManager::SetValue("tw_app_installed_in_system", 0);
1341 return false;
1342}
Chaosmaster461e39f2020-02-07 01:48:13 +01001343
epicX271bb3a2020-12-30 01:03:18 +05301344void TWFunc::checkforapp(){
1345
1346 string sdkverstr = System_Property_Get("ro.build.version.sdk");
1347 int sdkver = 0;
1348 if (!sdkverstr.empty()) {
1349 sdkver = atoi(sdkverstr.c_str());
1350 }
1351 if (sdkver <= 13) {
1352 if (sdkver == 0)
1353 LOGINFO("Unable to read sdk version from build prop\n");
1354 else
1355 LOGINFO("SDK version too low for TWRP app (%i < 14)\n", sdkver);
1356 DataManager::SetValue("tw_app_install_status", 1); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1357 goto exit;
1358 }
1359 if (Is_TWRP_App_In_System()) {
1360 DataManager::SetValue("tw_app_install_status", 2); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1361 goto exit;
1362 }
1363 if (PartitionManager.Mount_By_Path("/data", false)) {
1364 const char parent_path[] = "/data/app";
1365 const char app_prefix[] = "me.twrp.twrpapp-";
1366 DIR *d = opendir(parent_path);
1367 if (d) {
1368 struct dirent *p;
1369 while ((p = readdir(d))) {
1370 if (p->d_type != DT_DIR || strlen(p->d_name) < strlen(app_prefix) || strncmp(p->d_name, app_prefix, strlen(app_prefix)))
1371 continue;
1372 closedir(d);
1373 LOGINFO("App found at '%s/%s'\n", parent_path, p->d_name);
1374 DataManager::SetValue("tw_app_install_status", 2); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1375 goto exit;
1376 }
1377 closedir(d);
1378 }
1379 } else {
1380 LOGINFO("Data partition cannot be mounted during app check\n");
1381 DataManager::SetValue("tw_app_install_status", 2); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1382 }
1383
1384 LOGINFO("App not installed\n");
1385 DataManager::SetValue("tw_app_install_status", 1); // 0 = no status, 1 = not installed, 2 = already installed
1386exit:
1387 return;
1388
1389}
1390
Chaosmaster461e39f2020-02-07 01:48:13 +01001391int TWFunc::Property_Override(string Prop_Name, string Prop_Value) {
1392#ifdef TW_INCLUDE_LIBRESETPROP
1393 return setprop(Prop_Name.c_str(), Prop_Value.c_str(), false);
1394#else
1395 return -2;
1396#endif
1397}
1398
bigbiffee7b7ff2020-03-23 15:08:27 -04001399void TWFunc::List_Mounts() {
1400 std::vector<std::string> mounts;
1401 read_file("/proc/mounts", mounts);
1402 LOGINFO("Mounts:\n");
1403 for (auto&& mount: mounts) {
1404 LOGINFO("%s\n", mount.c_str());
1405 }
1406}
1407
bigbiffa957f072021-03-07 18:20:29 -05001408#ifdef TW_INCLUDE_CRYPTO
1409#ifdef USE_FSCRYPT_POLICY_V1
1410bool TWFunc::Get_Encryption_Policy(struct fscrypt_policy_v1 &policy, std::string path) {
1411#else
1412bool TWFunc::Get_Encryption_Policy(struct fscrypt_policy_v2 &policy, std::string path) {
1413#endif
bigbiff7ba75002020-04-11 20:47:09 -04001414 if (!TWFunc::Path_Exists(path)) {
1415 LOGERR("Unable to find %s to get policy\n", path.c_str());
1416 return false;
1417 }
1418 if (!fscrypt_policy_get_struct(path.c_str(), &policy)) {
1419 LOGERR("No policy set for path %s\n", path.c_str());
1420 return false;
1421 }
1422 return true;
1423}
1424
bigbiffa957f072021-03-07 18:20:29 -05001425#ifdef USE_FSCRYPT_POLICY_V1
1426bool TWFunc::Set_Encryption_Policy(std::string path, struct fscrypt_policy_v1 &policy) {
1427#else
1428bool TWFunc::Set_Encryption_Policy(std::string path, struct fscrypt_policy_v2 &policy) {
1429#endif
bigbiff7ba75002020-04-11 20:47:09 -04001430 if (!TWFunc::Path_Exists(path)) {
1431 LOGERR("unable to find %s to set policy\n", path.c_str());
1432 return false;
1433 }
1434 uint8_t binary_policy[FS_KEY_DESCRIPTOR_SIZE];
bigbiffa957f072021-03-07 18:20:29 -05001435 char policy_hex[FSCRYPT_KEY_IDENTIFIER_HEX_SIZE];
1436 bytes_to_hex(binary_policy, FS_KEY_DESCRIPTOR_SIZE, policy_hex);
bigbiff7ba75002020-04-11 20:47:09 -04001437 if (!fscrypt_policy_set_struct(path.c_str(), &policy)) {
1438 LOGERR("unable to set policy for path: %s\n", path.c_str());
1439 return false;
1440 }
1441 return true;
1442}
bigbiffa957f072021-03-07 18:20:29 -05001443#endif
epicXa721f952021-01-04 13:01:31 +05301444
1445string TWFunc::Check_For_TwrpFolder() {
1446 string oldFolder = "";
1447 vector<string> customTWRPFolders;
1448 string mainPath = DataManager::GetCurrentStoragePath();
1449 DIR* d;
1450 struct dirent* de;
1451
epicX11e90832021-03-01 00:02:57 +05301452 if (DataManager::GetIntValue(TW_IS_ENCRYPTED)) {
epicXa721f952021-01-04 13:01:31 +05301453 goto exit;
1454 }
1455
1456
1457 d = opendir(mainPath.c_str());
1458 if (d == NULL) {
1459 goto exit;
1460 }
1461
1462 while ((de = readdir(d)) != NULL) {
1463 string name = de->d_name;
1464 string fullPath = mainPath + '/' + name;
1465 unsigned char type = de->d_type;
1466
epicX11e90832021-03-01 00:02:57 +05301467 if (name == "." || name == "..") continue;
epicXa721f952021-01-04 13:01:31 +05301468
epicX11e90832021-03-01 00:02:57 +05301469 if (type == DT_UNKNOWN) {
epicXa721f952021-01-04 13:01:31 +05301470 type = Get_D_Type_From_Stat(fullPath);
1471 }
1472
epicX11e90832021-03-01 00:02:57 +05301473 if (type == DT_DIR && Path_Exists(fullPath + '/' + TW_SETTINGS_FILE)) {
1474 if ('/' + name == TW_DEFAULT_RECOVERY_FOLDER) {
epicXa721f952021-01-04 13:01:31 +05301475 oldFolder = name;
1476 } else {
1477 customTWRPFolders.push_back(name);
1478 }
1479 }
1480 }
1481
1482 closedir(d);
1483
epicX11e90832021-03-01 00:02:57 +05301484 if (oldFolder == "" && customTWRPFolders.empty()) {
epicXa721f952021-01-04 13:01:31 +05301485 LOGINFO("No recovery folder found. Using default folder.\n");
1486 goto exit;
epicX11e90832021-03-01 00:02:57 +05301487 } else if (customTWRPFolders.empty()) {
epicXa721f952021-01-04 13:01:31 +05301488 LOGINFO("No custom recovery folder found. Using TWRP as default.\n");
1489 goto exit;
1490 } else {
epicX11e90832021-03-01 00:02:57 +05301491 if (customTWRPFolders.size() > 1) {
epicXa721f952021-01-04 13:01:31 +05301492 LOGINFO("More than one custom recovery folder found. Using first one from the list.\n");
1493 } else {
1494 LOGINFO("One custom recovery folder found.\n");
1495 }
1496 string customPath = '/' + customTWRPFolders.at(0);
1497
epicX11e90832021-03-01 00:02:57 +05301498 if (Path_Exists(mainPath + TW_DEFAULT_RECOVERY_FOLDER)) {
epicXa721f952021-01-04 13:01:31 +05301499 string oldBackupFolder = mainPath + TW_DEFAULT_RECOVERY_FOLDER + "/BACKUPS/" + DataManager::GetStrValue("device_id");
1500 string newBackupFolder = mainPath + customPath + "/BACKUPS/" + DataManager::GetStrValue("device_id");
1501
epicX11e90832021-03-01 00:02:57 +05301502 if (Path_Exists(oldBackupFolder)) {
epicXa721f952021-01-04 13:01:31 +05301503 vector<string> backups;
1504 d = opendir(oldBackupFolder.c_str());
1505
1506 if (d != NULL) {
1507 while ((de = readdir(d)) != NULL) {
1508 string name = de->d_name;
1509 unsigned char type = de->d_type;
1510
epicX11e90832021-03-01 00:02:57 +05301511 if (name == "." || name == "..") continue;
epicXa721f952021-01-04 13:01:31 +05301512
epicX11e90832021-03-01 00:02:57 +05301513 if (type == DT_UNKNOWN) {
epicXa721f952021-01-04 13:01:31 +05301514 type = Get_D_Type_From_Stat(mainPath + '/' + name);
1515 }
1516
epicX11e90832021-03-01 00:02:57 +05301517 if (type == DT_DIR) {
epicXa721f952021-01-04 13:01:31 +05301518 backups.push_back(name);
1519 }
1520 }
1521 closedir(d);
1522 }
1523
epicX11e90832021-03-01 00:02:57 +05301524 for (auto it = backups.begin(); it != backups.end(); it++) {
epicXa721f952021-01-04 13:01:31 +05301525 Exec_Cmd("mv -f \"" + oldBackupFolder + '/' + *it + "\" \"" + newBackupFolder + '/' + *it + (Path_Exists(newBackupFolder + '/' + *it) ? "_new\"" : "\""));
1526 }
1527 }
1528 Exec_Cmd("rm -rf \"" + mainPath + TW_DEFAULT_RECOVERY_FOLDER + '\"');
1529 }
1530
1531 return customPath;
1532 }
1533
1534exit:
1535 return TW_DEFAULT_RECOVERY_FOLDER;
1536}
zhenyolkaee025852021-11-08 19:05:30 +03001537
1538bool TWFunc::Check_Xml_Format(const std::string filename) {
1539 std::string buffer(' ', 4);
1540 std::string abx_hdr("ABX\x00", 4);
1541 std::ifstream File;
1542 File.open(filename);
1543 if (File.is_open()) {
1544 File.get(&buffer[0], buffer.size());
1545 File.close();
1546 // Android Binary Xml start from these bytes
1547 if(!buffer.compare(0, abx_hdr.size(), abx_hdr))
1548 return false; // bad format, not possible to parse
1549 }
1550 return true; // good format, possible to parse
1551}
1552
Ethan Yonkeraf2897c2014-02-10 13:07:14 -06001553#endif // ndef BUILD_TWRPTAR_MAIN