blob: 983d277fa6e7f9e6664c57c55b3264a860e2ad22 [file] [log] [blame]
Dees Troy3be70a82013-10-22 14:25:12 +00001/*
2 Copyright 2012 bigbiff/Dees_Troy TeamWin
3 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>
Dees_Troy38bd7602012-09-14 13:33:53 -040041#include "twrp-functions.hpp"
Dees_Troy2673cec2013-04-02 20:22:16 +000042#include "twcommon.h"
Ethan Yonker472f5062016-02-25 13:47:30 -060043#include "gui/gui.hpp"
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060044#ifndef BUILD_TWRPTAR_MAIN
Dees_Troyb46a6842012-09-25 11:06:46 -040045#include "data.hpp"
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060046#include "partitions.hpp"
Dees_Troy3477d712012-09-27 15:44:01 -040047#include "variables.h"
Ethan Yonker8373cfe2017-09-08 06:50:54 -050048#include "bootloader_message_twrp/include/bootloader_message_twrp/bootloader_message.h"
Tom Hite5a926722014-09-15 01:31:03 +000049#include "cutils/properties.h"
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -050050#include "cutils/android_reboot.h"
51#include <sys/reboot.h>
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060052#endif // ndef BUILD_TWRPTAR_MAIN
Dees_Troy83bd4832013-05-04 12:39:56 +000053#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
54 #include "openaes/inc/oaes_lib.h"
55#endif
Ethan Yonkerf1179622016-08-25 15:32:21 -050056#include "set_metadata.h"
Dees_Troy38bd7602012-09-14 13:33:53 -040057
Dees_Troyb05ddee2013-01-28 20:24:50 +000058extern "C" {
59 #include "libcrecovery/common.h"
60}
61
Chaosmaster461e39f2020-02-07 01:48:13 +010062#ifdef TW_INCLUDE_LIBRESETPROP
63 #include <resetprop.h>
64#endif
65
bigbiff bigbiff19874f12019-01-08 20:06:57 -050066struct selabel_handle *selinux_handle;
67
bigbiff bigbiff9c754052013-01-09 09:09:08 -050068/* Execute a command */
bigbiff56b02eb2020-07-06 20:24:34 -040069int TWFunc::Exec_Cmd(const string& cmd, string &result, bool combine_stderr) {
Dees_Troy29a06352013-08-24 12:06:47 +000070 FILE* exec;
71 char buffer[130];
72 int ret = 0;
bigbiff56b02eb2020-07-06 20:24:34 -040073 std::string popen_cmd = cmd;
74 if (combine_stderr)
75 popen_cmd = cmd + " 2>&1";
76 exec = __popen(popen_cmd.c_str(), "r");
77
Matt Mowera8a89d12016-12-30 18:10:37 -060078 while (!feof(exec)) {
Dees_Troy29a06352013-08-24 12:06:47 +000079 if (fgets(buffer, 128, exec) != NULL) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -050080 result += buffer;
Dees_Troyb05ddee2013-01-28 20:24:50 +000081 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -050082 }
Dees_Troy29a06352013-08-24 12:06:47 +000083 ret = __pclose(exec);
84 return ret;
bigbiff bigbiff9c754052013-01-09 09:09:08 -050085}
86
Ethan Yonker7e941582019-03-22 08:18:21 -050087int TWFunc::Exec_Cmd(const string& cmd, bool Show_Errors) {
Vojtech Bocek05534202013-09-11 08:11:56 +020088 pid_t pid;
89 int status;
90 switch(pid = fork())
91 {
92 case -1:
bigbiff bigbiff731df792014-02-20 18:26:13 -050093 LOGERR("Exec_Cmd(): vfork failed: %d!\n", errno);
Vojtech Bocek05534202013-09-11 08:11:56 +020094 return -1;
95 case 0: // child
96 execl("/sbin/sh", "sh", "-c", cmd.c_str(), NULL);
97 _exit(127);
98 break;
99 default:
100 {
Ethan Yonker7e941582019-03-22 08:18:21 -0500101 if (TWFunc::Wait_For_Child(pid, &status, cmd, Show_Errors) != 0)
Vojtech Bocek05534202013-09-11 08:11:56 +0200102 return -1;
103 else
104 return 0;
105 }
106 }
107}
108
Dees_Troy38bd7602012-09-14 13:33:53 -0400109// Returns "file.name" from a full /path/to/file.name
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600110string TWFunc::Get_Filename(const string& Path) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400111 size_t pos = Path.find_last_of("/");
112 if (pos != string::npos) {
113 string Filename;
114 Filename = Path.substr(pos + 1, Path.size() - pos - 1);
115 return Filename;
116 } else
117 return Path;
118}
119
120// Returns "/path/to/" from a full /path/to/file.name
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600121string TWFunc::Get_Path(const string& Path) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400122 size_t pos = Path.find_last_of("/");
123 if (pos != string::npos) {
124 string Pathonly;
125 Pathonly = Path.substr(0, pos + 1);
126 return Pathonly;
127 } else
128 return Path;
129}
130
Ethan Yonker7e941582019-03-22 08:18:21 -0500131int TWFunc::Wait_For_Child(pid_t pid, int *status, string Child_Name, bool Show_Errors) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600132 pid_t rc_pid;
133
134 rc_pid = waitpid(pid, status, 0);
135 if (rc_pid > 0) {
Vojtech Bocek0fdcbec2015-03-20 15:36:40 +0100136 if (WIFSIGNALED(*status)) {
Ethan Yonker7e941582019-03-22 08:18:21 -0500137 if (Show_Errors)
138 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 -0600139 return -1;
Vojtech Bocek0fdcbec2015-03-20 15:36:40 +0100140 } else if (WEXITSTATUS(*status) == 0) {
141 LOGINFO("%s process ended with RC=%d\n", Child_Name.c_str(), WEXITSTATUS(*status)); // Success
142 } else {
Ethan Yonker7e941582019-03-22 08:18:21 -0500143 if (Show_Errors)
144 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 -0600145 return -1;
146 }
147 } else { // no PID returned
148 if (errno == ECHILD)
that2252d242015-04-03 22:33:04 +0200149 LOGERR("%s no child process exist\n", Child_Name.c_str());
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600150 else {
that2252d242015-04-03 22:33:04 +0200151 LOGERR("%s Unexpected error %d\n", Child_Name.c_str(), errno);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600152 return -1;
153 }
154 }
155 return 0;
156}
157
Ethan Yonkerddb63e22017-01-19 14:01:57 -0600158int TWFunc::Wait_For_Child_Timeout(pid_t pid, int *status, const string& Child_Name, int timeout) {
159 pid_t retpid = waitpid(pid, status, WNOHANG);
160 for (; retpid == 0 && timeout; --timeout) {
161 sleep(1);
162 retpid = waitpid(pid, status, WNOHANG);
163 }
164 if (retpid == 0 && timeout == 0) {
165 LOGERR("%s took too long, killing process\n", Child_Name.c_str());
166 kill(pid, SIGKILL);
Ethan Yonkerddb63e22017-01-19 14:01:57 -0600167 for (timeout = 5; retpid == 0 && timeout; --timeout) {
168 sleep(1);
169 retpid = waitpid(pid, status, WNOHANG);
170 }
171 if (retpid)
172 LOGINFO("Child process killed successfully\n");
173 else
174 LOGINFO("Child process took too long to kill, may be a zombie process\n");
175 return -1;
176 } else if (retpid > 0) {
177 if (WIFSIGNALED(*status)) {
178 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
179 return -1;
180 }
181 } else if (retpid < 0) { // no PID returned
182 if (errno == ECHILD)
183 LOGERR("%s no child process exist\n", Child_Name.c_str());
184 else {
185 LOGERR("%s Unexpected error %d\n", Child_Name.c_str(), errno);
186 return -1;
187 }
188 }
189 return 0;
190}
191
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600192bool TWFunc::Path_Exists(string Path) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600193 struct stat st;
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400194 return stat(Path.c_str(), &st) == 0;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600195}
196
bigbiffce8f83c2015-12-12 18:30:21 -0500197Archive_Type TWFunc::Get_File_Type(string fn) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600198 string::size_type i = 0;
199 int firstbyte = 0, secondbyte = 0;
200 char header[3];
201
202 ifstream f;
203 f.open(fn.c_str(), ios::in | ios::binary);
204 f.get(header, 3);
205 f.close();
206 firstbyte = header[i] & 0xff;
207 secondbyte = header[++i] & 0xff;
208
209 if (firstbyte == 0x1f && secondbyte == 0x8b)
bigbiffce8f83c2015-12-12 18:30:21 -0500210 return COMPRESSED;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600211 else if (firstbyte == 0x4f && secondbyte == 0x41)
bigbiffce8f83c2015-12-12 18:30:21 -0500212 return ENCRYPTED;
213 return UNCOMPRESSED; // default
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600214}
215
216int TWFunc::Try_Decrypting_File(string fn, string password) {
217#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
218 OAES_CTX * ctx = NULL;
219 uint8_t _key_data[32] = "";
220 FILE *f;
221 uint8_t buffer[4096];
222 uint8_t *buffer_out = NULL;
223 uint8_t *ptr = NULL;
224 size_t read_len = 0, out_len = 0;
Matt Mower23d8aae2017-01-06 14:30:33 -0600225 int firstbyte = 0, secondbyte = 0;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600226 size_t _j = 0;
227 size_t _key_data_len = 0;
228
229 // mostly kanged from OpenAES oaes.c
Matt Mowera8a89d12016-12-30 18:10:37 -0600230 for ( _j = 0; _j < 32; _j++ )
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600231 _key_data[_j] = _j + 1;
232 _key_data_len = password.size();
Matt Mowera8a89d12016-12-30 18:10:37 -0600233 if ( 16 >= _key_data_len )
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600234 _key_data_len = 16;
Matt Mowera8a89d12016-12-30 18:10:37 -0600235 else if ( 24 >= _key_data_len )
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600236 _key_data_len = 24;
237 else
Matt Mowera8a89d12016-12-30 18:10:37 -0600238 _key_data_len = 32;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600239 memcpy(_key_data, password.c_str(), password.size());
240
241 ctx = oaes_alloc();
242 if (ctx == NULL) {
243 LOGERR("Failed to allocate OAES\n");
244 return -1;
245 }
246
247 oaes_key_import_data(ctx, _key_data, _key_data_len);
248
249 f = fopen(fn.c_str(), "rb");
250 if (f == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500251 LOGERR("Failed to open '%s' to try decrypt: %s\n", fn.c_str(), strerror(errno));
Matt Mower13a8f0b2015-09-26 15:40:03 -0500252 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600253 return -1;
254 }
255 read_len = fread(buffer, sizeof(uint8_t), 4096, f);
256 if (read_len <= 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500257 LOGERR("Read size during try decrypt failed: %s\n", strerror(errno));
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600258 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500259 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600260 return -1;
261 }
262 if (oaes_decrypt(ctx, buffer, read_len, NULL, &out_len) != OAES_RET_SUCCESS) {
263 LOGERR("Error: Failed to retrieve required buffer size for trying decryption.\n");
264 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500265 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600266 return -1;
267 }
268 buffer_out = (uint8_t *) calloc(out_len, sizeof(char));
269 if (buffer_out == NULL) {
270 LOGERR("Failed to allocate output buffer for try decrypt.\n");
271 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500272 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600273 return -1;
274 }
275 if (oaes_decrypt(ctx, buffer, read_len, buffer_out, &out_len) != OAES_RET_SUCCESS) {
276 LOGERR("Failed to decrypt file '%s'\n", fn.c_str());
277 fclose(f);
278 free(buffer_out);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500279 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600280 return 0;
281 }
282 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500283 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600284 if (out_len < 2) {
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500285 LOGINFO("Successfully decrypted '%s' but read length too small.\n", fn.c_str());
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600286 free(buffer_out);
287 return 1; // Decrypted successfully
288 }
289 ptr = buffer_out;
290 firstbyte = *ptr & 0xff;
291 ptr++;
292 secondbyte = *ptr & 0xff;
293 if (firstbyte == 0x1f && secondbyte == 0x8b) {
294 LOGINFO("Successfully decrypted '%s' and file is compressed.\n", fn.c_str());
295 free(buffer_out);
296 return 3; // Compressed
297 }
298 if (out_len >= 262) {
299 ptr = buffer_out + 257;
300 if (strncmp((char*)ptr, "ustar", 5) == 0) {
301 LOGINFO("Successfully decrypted '%s' and file is tar format.\n", fn.c_str());
302 free(buffer_out);
303 return 2; // Tar
304 }
305 }
306 free(buffer_out);
307 LOGINFO("No errors decrypting '%s' but no known file format.\n", fn.c_str());
308 return 1; // Decrypted successfully
309#else
310 LOGERR("Encrypted backup support not included.\n");
311 return -1;
312#endif
313}
314
Ethan Yonker472f5062016-02-25 13:47:30 -0600315unsigned long TWFunc::Get_File_Size(const string& Path) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600316 struct stat st;
317
318 if (stat(Path.c_str(), &st) != 0)
319 return 0;
320 return st.st_size;
321}
322
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100323std::string TWFunc::Remove_Trailing_Slashes(const std::string& path, bool leaveLast)
324{
325 std::string res;
326 size_t last_idx = 0, idx = 0;
327
Matt Mowera8a89d12016-12-30 18:10:37 -0600328 while (last_idx != std::string::npos)
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100329 {
Matt Mowera8a89d12016-12-30 18:10:37 -0600330 if (last_idx != 0)
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100331 res += '/';
332
333 idx = path.find_first_of('/', last_idx);
Matt Mowera8a89d12016-12-30 18:10:37 -0600334 if (idx == std::string::npos) {
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100335 res += path.substr(last_idx, idx);
336 break;
337 }
338
339 res += path.substr(last_idx, idx-last_idx);
340 last_idx = path.find_first_not_of('/', idx);
341 }
342
Matt Mowera8a89d12016-12-30 18:10:37 -0600343 if (leaveLast)
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100344 res += '/';
345 return res;
346}
347
Matt Mower2416a502016-04-12 19:54:46 -0500348void TWFunc::Strip_Quotes(char* &str) {
349 if (strlen(str) > 0 && str[0] == '\"')
350 str++;
351 if (strlen(str) > 0 && str[strlen(str)-1] == '\"')
352 str[strlen(str)-1] = 0;
353}
354
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500355vector<string> TWFunc::split_string(const string &in, char del, bool skip_empty) {
356 vector<string> res;
357
358 if (in.empty() || del == '\0')
359 return res;
360
361 string field;
362 istringstream f(in);
363 if (del == '\n') {
Matt Mowera8a89d12016-12-30 18:10:37 -0600364 while (getline(f, field)) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500365 if (field.empty() && skip_empty)
366 continue;
Matt Mowera8a89d12016-12-30 18:10:37 -0600367 res.push_back(field);
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500368 }
369 } else {
Matt Mowera8a89d12016-12-30 18:10:37 -0600370 while (getline(f, field, del)) {
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500371 if (field.empty() && skip_empty)
372 continue;
373 res.push_back(field);
374 }
375 }
376 return res;
377}
378
Ethan Yonker472f5062016-02-25 13:47:30 -0600379timespec TWFunc::timespec_diff(timespec& start, timespec& end)
380{
381 timespec temp;
382 if ((end.tv_nsec-start.tv_nsec)<0) {
383 temp.tv_sec = end.tv_sec-start.tv_sec-1;
384 temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
385 } else {
386 temp.tv_sec = end.tv_sec-start.tv_sec;
387 temp.tv_nsec = end.tv_nsec-start.tv_nsec;
388 }
389 return temp;
390}
391
392int32_t TWFunc::timespec_diff_ms(timespec& start, timespec& end)
393{
394 return ((end.tv_sec * 1000) + end.tv_nsec/1000000) -
395 ((start.tv_sec * 1000) + start.tv_nsec/1000000);
396}
397
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600398#ifndef BUILD_TWRPTAR_MAIN
399
Dees_Troy38bd7602012-09-14 13:33:53 -0400400// Returns "/path" from a full /path/to/file.name
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600401string TWFunc::Get_Root_Path(const string& Path) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400402 string Local_Path = Path;
403
404 // Make sure that we have a leading slash
405 if (Local_Path.substr(0, 1) != "/")
406 Local_Path = "/" + Local_Path;
407
408 // Trim the path to get the root path only
409 size_t position = Local_Path.find("/", 2);
410 if (position != string::npos) {
411 Local_Path.resize(position);
412 }
413 return Local_Path;
414}
415
416void TWFunc::install_htc_dumlock(void) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400417 int need_libs = 0;
418
Captain Throwback9d6feb52018-07-27 10:05:24 -0400419 if (!PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), true))
Dees_Troy38bd7602012-09-14 13:33:53 -0400420 return;
421
422 if (!PartitionManager.Mount_By_Path("/data", true))
423 return;
424
Ethan Yonker74db1572015-10-28 12:44:49 -0500425 gui_msg("install_dumlock=Installing HTC Dumlock to system...");
Dees Troy3454ade2015-01-20 19:21:04 +0000426 copy_file(TWHTCD_PATH "htcdumlocksys", "/system/bin/htcdumlock", 0755);
Dees_Troy8170a922012-09-18 15:40:25 -0400427 if (!Path_Exists("/system/bin/flash_image")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500428 LOGINFO("Installing flash_image...\n");
Dees Troy3454ade2015-01-20 19:21:04 +0000429 copy_file(TWHTCD_PATH "flash_imagesys", "/system/bin/flash_image", 0755);
Dees_Troy38bd7602012-09-14 13:33:53 -0400430 need_libs = 1;
431 } else
Ethan Yonker74db1572015-10-28 12:44:49 -0500432 LOGINFO("flash_image is already installed, skipping...\n");
Dees_Troy8170a922012-09-18 15:40:25 -0400433 if (!Path_Exists("/system/bin/dump_image")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500434 LOGINFO("Installing dump_image...\n");
Dees Troy3454ade2015-01-20 19:21:04 +0000435 copy_file(TWHTCD_PATH "dump_imagesys", "/system/bin/dump_image", 0755);
Dees_Troy38bd7602012-09-14 13:33:53 -0400436 need_libs = 1;
437 } else
Ethan Yonker74db1572015-10-28 12:44:49 -0500438 LOGINFO("dump_image is already installed, skipping...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400439 if (need_libs) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500440 LOGINFO("Installing libs needed for flash_image and dump_image...\n");
Dees Troy3454ade2015-01-20 19:21:04 +0000441 copy_file(TWHTCD_PATH "libbmlutils.so", "/system/lib/libbmlutils.so", 0644);
442 copy_file(TWHTCD_PATH "libflashutils.so", "/system/lib/libflashutils.so", 0644);
443 copy_file(TWHTCD_PATH "libmmcutils.so", "/system/lib/libmmcutils.so", 0644);
444 copy_file(TWHTCD_PATH "libmtdutils.so", "/system/lib/libmtdutils.so", 0644);
Dees_Troy38bd7602012-09-14 13:33:53 -0400445 }
Ethan Yonker74db1572015-10-28 12:44:49 -0500446 LOGINFO("Installing HTC Dumlock app...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400447 mkdir("/data/app", 0777);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500448 unlink("/data/app/com.teamwin.htcdumlock*");
Dees Troy3454ade2015-01-20 19:21:04 +0000449 copy_file(TWHTCD_PATH "HTCDumlock.apk", "/data/app/com.teamwin.htcdumlock.apk", 0777);
Dees_Troy38bd7602012-09-14 13:33:53 -0400450 sync();
Ethan Yonker74db1572015-10-28 12:44:49 -0500451 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -0400452}
453
454void TWFunc::htc_dumlock_restore_original_boot(void) {
455 if (!PartitionManager.Mount_By_Path("/sdcard", true))
456 return;
457
Ethan Yonker74db1572015-10-28 12:44:49 -0500458 gui_msg("dumlock_restore=Restoring original boot...");
Vojtech Bocek05534202013-09-11 08:11:56 +0200459 Exec_Cmd("htcdumlock restore");
Ethan Yonker74db1572015-10-28 12:44:49 -0500460 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -0400461}
462
463void TWFunc::htc_dumlock_reflash_recovery_to_boot(void) {
464 if (!PartitionManager.Mount_By_Path("/sdcard", true))
465 return;
Ethan Yonker74db1572015-10-28 12:44:49 -0500466 gui_msg("dumlock_reflash=Reflashing recovery to boot...");
Vojtech Bocek05534202013-09-11 08:11:56 +0200467 Exec_Cmd("htcdumlock recovery noreboot");
Ethan Yonker74db1572015-10-28 12:44:49 -0500468 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -0400469}
Dees_Troy43d8b002012-09-17 16:00:01 -0400470
471int TWFunc::Recursive_Mkdir(string Path) {
thatf1408b32016-01-03 11:09:15 +0100472 std::vector<std::string> parts = Split_String(Path, "/", true);
473 std::string cur_path;
474 for (size_t i = 0; i < parts.size(); ++i) {
475 cur_path += "/" + parts[i];
476 if (!TWFunc::Path_Exists(cur_path)) {
477 if (mkdir(cur_path.c_str(), 0777)) {
Matt Mower3c366972015-12-25 19:28:31 -0600478 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 -0600479 return false;
480 } else {
thatf1408b32016-01-03 11:09:15 +0100481 tw_set_default_metadata(cur_path.c_str());
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600482 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400483 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400484 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400485 return true;
486}
487
Dees_Troyb46a6842012-09-25 11:06:46 -0400488void TWFunc::GUI_Operation_Text(string Read_Value, string Default_Text) {
489 string Display_Text;
490
491 DataManager::GetValue(Read_Value, Display_Text);
492 if (Display_Text.empty())
493 Display_Text = Default_Text;
494
495 DataManager::SetValue("tw_operation", Display_Text);
496 DataManager::SetValue("tw_partition", "");
497}
498
499void TWFunc::GUI_Operation_Text(string Read_Value, string Partition_Name, string Default_Text) {
500 string Display_Text;
501
502 DataManager::GetValue(Read_Value, Display_Text);
503 if (Display_Text.empty())
504 Display_Text = Default_Text;
505
506 DataManager::SetValue("tw_operation", Display_Text);
507 DataManager::SetValue("tw_partition", Partition_Name);
Dees_Troy7c2dec82012-09-26 09:49:14 -0400508}
509
Dees_Troy2673cec2013-04-02 20:22:16 +0000510void TWFunc::Copy_Log(string Source, string Destination) {
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400511 int logPipe[2];
512 int pigz_pid;
513 int destination_fd;
514 std::string destLogBuffer;
515
Dees Troy9d7fdf52013-09-19 20:49:25 +0000516 PartitionManager.Mount_By_Path(Destination, false);
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400517
518 size_t extPos = Destination.find(".gz");
519 std::string uncompressedLog(Destination);
520 uncompressedLog.replace(extPos, Destination.length(), "");
521
522 if (Path_Exists(Destination)) {
523 Archive_Type type = Get_File_Type(Destination);
524 if (type == COMPRESSED) {
525 std::string destFileBuffer;
526 std::string getCompressedContents = "pigz -c -d " + Destination;
bigbiff56b02eb2020-07-06 20:24:34 -0400527 if (Exec_Cmd(getCompressedContents, destFileBuffer, false) < 0) {
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400528 LOGINFO("Unable to get destination logfile contents.\n");
529 return;
530 }
531 destLogBuffer.append(destFileBuffer);
Dees_Troy6ef66352013-02-21 08:26:57 -0600532 }
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400533 } else if (Path_Exists(uncompressedLog)) {
bigbiffd3317052019-12-22 16:05:12 -0500534 std::ifstream uncompressedIfs(uncompressedLog.c_str());
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400535 std::stringstream uncompressedSS;
536 uncompressedSS << uncompressedIfs.rdbuf();
537 uncompressedIfs.close();
538 std::string uncompressedLogBuffer(uncompressedSS.str());
539 destLogBuffer.append(uncompressedLogBuffer);
540 std::remove(uncompressedLog.c_str());
Dees_Troy6ef66352013-02-21 08:26:57 -0600541 }
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400542
bigbiffd3317052019-12-22 16:05:12 -0500543 std::ifstream ifs(Source.c_str());
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400544 std::stringstream ss;
545 ss << ifs.rdbuf();
546 std::string srcLogBuffer(ss.str());
547 ifs.close();
548
549 if (pipe(logPipe) < 0) {
550 LOGINFO("Unable to open pipe to write to persistent log file: %s\n", Destination.c_str());
551 }
552
553 destination_fd = open(Destination.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
554
555 pigz_pid = fork();
556 if (pigz_pid < 0) {
557 LOGINFO("fork() failed\n");
558 close(destination_fd);
559 close(logPipe[0]);
560 close(logPipe[1]);
561 } else if (pigz_pid == 0) {
562 close(logPipe[1]);
563 dup2(logPipe[0], fileno(stdin));
564 dup2(destination_fd, fileno(stdout));
565 if (execlp("pigz", "pigz", "-", NULL) < 0) {
566 close(destination_fd);
567 close(logPipe[0]);
568 _exit(-1);
569 }
570 } else {
571 close(logPipe[0]);
572 if (write(logPipe[1], destLogBuffer.c_str(), destLogBuffer.size()) < 0) {
573 LOGINFO("Unable to append to persistent log: %s\n", Destination.c_str());
574 close(logPipe[1]);
575 close(destination_fd);
576 return;
577 }
578 if (write(logPipe[1], srcLogBuffer.c_str(), srcLogBuffer.size()) < 0) {
579 LOGINFO("Unable to append to persistent log: %s\n", Destination.c_str());
580 close(logPipe[1]);
581 close(destination_fd);
582 return;
583 }
584 close(logPipe[1]);
585 }
586 close(destination_fd);
Dees_Troya58bead2012-09-27 09:49:29 -0400587}
588
Dees_Troy2673cec2013-04-02 20:22:16 +0000589void TWFunc::Update_Log_File(void) {
bigbiff349ea552020-06-19 16:07:38 -0400590 std::string recoveryDir = get_log_dir() + "recovery/";
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500591
bigbiff349ea552020-06-19 16:07:38 -0400592 if (get_log_dir() == CACHE_LOGS_DIR) {
593 if (!PartitionManager.Mount_By_Path(CACHE_LOGS_DIR, false)) {
594 LOGINFO("Failed to mount %s for TWFunc::Update_Log_File\n", CACHE_LOGS_DIR);
Dees Troy9d7fdf52013-09-19 20:49:25 +0000595 }
Dees Troy9d7fdf52013-09-19 20:49:25 +0000596 }
Dees_Troya58bead2012-09-27 09:49:29 -0400597
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500598 if (!TWFunc::Path_Exists(recoveryDir)) {
599 LOGINFO("Recreating %s folder.\n", recoveryDir.c_str());
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -0400600 if (!Create_Dir_Recursive(recoveryDir, S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP, 0, 0)) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500601 LOGINFO("Unable to create %s folder.\n", recoveryDir.c_str());
602 }
603 }
604
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400605 std::string logCopy = recoveryDir + "log.gz";
606 std::string lastLogCopy = recoveryDir + "last_log.gz";
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500607 copy_file(logCopy, lastLogCopy, 600);
608 Copy_Log(TMP_LOG_FILE, logCopy);
609 chown(logCopy.c_str(), 1000, 1000);
610 chmod(logCopy.c_str(), 0600);
611 chmod(lastLogCopy.c_str(), 0640);
612
Dees_Troy2673cec2013-04-02 20:22:16 +0000613 // Reset bootloader message
614 TWPartition* Part = PartitionManager.Find_Partition_By_Path("/misc");
615 if (Part != NULL) {
Ethan Yonker8373cfe2017-09-08 06:50:54 -0500616 std::string err;
617 if (!clear_bootloader_message((void*)&err)) {
Ethan Yonkerb5236502016-11-19 22:24:59 -0600618 if (err == "no misc device set") {
619 LOGINFO("%s\n", err.c_str());
620 } else {
621 LOGERR("%s\n", err.c_str());
622 }
623 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000624 }
Dees_Troya58bead2012-09-27 09:49:29 -0400625
bigbiff349ea552020-06-19 16:07:38 -0400626 if (get_log_dir() == CACHE_LOGS_DIR) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -0500627 if (PartitionManager.Mount_By_Path("/cache", false)) {
628 if (unlink("/cache/recovery/command") && errno != ENOENT) {
629 LOGINFO("Can't unlink %s\n", "/cache/recovery/command");
630 }
Dees Troy9d7fdf52013-09-19 20:49:25 +0000631 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500632 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000633 sync();
634}
635
636void TWFunc::Update_Intent_File(string Intent) {
637 if (PartitionManager.Mount_By_Path("/cache", false) && !Intent.empty()) {
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600638 TWFunc::write_to_file("/cache/recovery/intent", Intent);
Dees_Troy2673cec2013-04-02 20:22:16 +0000639 }
Dees_Troya58bead2012-09-27 09:49:29 -0400640}
641
642// reboot: Reboot the system. Return -1 on error, no return on success
643int TWFunc::tw_reboot(RebootCommand command)
644{
Ethan Yonkerfe916112016-03-14 14:54:37 -0500645 DataManager::Flush();
bigbiff349ea552020-06-19 16:07:38 -0400646 Update_Log_File();
bigbiffa2bd7b72020-05-07 21:45:34 -0400647
Dees_Troya58bead2012-09-27 09:49:29 -0400648 // Always force a sync before we reboot
Dees_Troy6ef66352013-02-21 08:26:57 -0600649 sync();
Dees_Troya58bead2012-09-27 09:49:29 -0400650
Dees_Troy2673cec2013-04-02 20:22:16 +0000651 switch (command) {
652 case rb_current:
653 case rb_system:
Dees_Troy2673cec2013-04-02 20:22:16 +0000654 Update_Intent_File("s");
655 sync();
656 check_and_run_script("/sbin/rebootsystem.sh", "reboot system");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500657#ifdef ANDROID_RB_PROPERTY
658 return property_set(ANDROID_RB_PROPERTY, "reboot,");
659#elif defined(ANDROID_RB_RESTART)
660 return android_reboot(ANDROID_RB_RESTART, 0, 0);
661#else
Dees_Troy2673cec2013-04-02 20:22:16 +0000662 return reboot(RB_AUTOBOOT);
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500663#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000664 case rb_recovery:
665 check_and_run_script("/sbin/rebootrecovery.sh", "reboot recovery");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600666#ifdef ANDROID_RB_PROPERTY
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500667 return property_set(ANDROID_RB_PROPERTY, "reboot,recovery");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600668#else
669 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "recovery");
670#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000671 case rb_bootloader:
672 check_and_run_script("/sbin/rebootbootloader.sh", "reboot bootloader");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600673#ifdef ANDROID_RB_PROPERTY
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500674 return property_set(ANDROID_RB_PROPERTY, "reboot,bootloader");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600675#else
676 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "bootloader");
677#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000678 case rb_poweroff:
679 check_and_run_script("/sbin/poweroff.sh", "power off");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500680#ifdef ANDROID_RB_PROPERTY
681 return property_set(ANDROID_RB_PROPERTY, "shutdown,");
682#elif defined(ANDROID_RB_POWEROFF)
683 return android_reboot(ANDROID_RB_POWEROFF, 0, 0);
684#else
Dees_Troy2673cec2013-04-02 20:22:16 +0000685 return reboot(RB_POWER_OFF);
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500686#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000687 case rb_download:
688 check_and_run_script("/sbin/rebootdownload.sh", "reboot download");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600689#ifdef ANDROID_RB_PROPERTY
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500690 return property_set(ANDROID_RB_PROPERTY, "reboot,download");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600691#else
692 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "download");
693#endif
mauronofrioe9a49ef2018-10-03 13:38:16 +0200694 case rb_edl:
695 check_and_run_script("/sbin/rebootedl.sh", "reboot edl");
696#ifdef ANDROID_RB_PROPERTY
697 return property_set(ANDROID_RB_PROPERTY, "reboot,edl");
698#else
699 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "edl");
700#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000701 default:
702 return -1;
Dees_Troy6ef66352013-02-21 08:26:57 -0600703 }
704 return -1;
Dees_Troya58bead2012-09-27 09:49:29 -0400705}
706
707void TWFunc::check_and_run_script(const char* script_file, const char* display_name)
708{
709 // Check for and run startup script if script exists
710 struct stat st;
711 if (stat(script_file, &st) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500712 gui_msg(Msg("run_script=Running {1} script...")(display_name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500713 chmod(script_file, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
Vojtech Bocek05534202013-09-11 08:11:56 +0200714 TWFunc::Exec_Cmd(script_file);
Ethan Yonker74db1572015-10-28 12:44:49 -0500715 gui_msg("done=Done.");
Dees_Troya58bead2012-09-27 09:49:29 -0400716 }
Dees_Troy3477d712012-09-27 15:44:01 -0400717}
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500718
719int TWFunc::removeDir(const string path, bool skipParent) {
Dees_Troyce675462013-01-09 19:48:21 +0000720 DIR *d = opendir(path.c_str());
721 int r = 0;
722 string new_path;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500723
Dees_Troyce675462013-01-09 19:48:21 +0000724 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500725 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(path)(strerror(errno)));
Dees_Troyce675462013-01-09 19:48:21 +0000726 return -1;
727 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500728
Dees_Troyce675462013-01-09 19:48:21 +0000729 if (d) {
730 struct dirent *p;
731 while (!r && (p = readdir(d))) {
Dees_Troyce675462013-01-09 19:48:21 +0000732 if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
733 continue;
734 new_path = path + "/";
735 new_path.append(p->d_name);
736 if (p->d_type == DT_DIR) {
737 r = removeDir(new_path, true);
738 if (!r) {
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500739 if (p->d_type == DT_DIR)
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500740 r = rmdir(new_path.c_str());
741 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000742 LOGINFO("Unable to removeDir '%s': %s\n", new_path.c_str(), strerror(errno));
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500743 }
bigbiff bigbiff98f1f902013-01-19 18:46:13 -0500744 } 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 +0000745 r = unlink(new_path.c_str());
Dees_Troye34c1332013-02-06 19:13:00 +0000746 if (r != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000747 LOGINFO("Unable to unlink '%s: %s'\n", new_path.c_str(), strerror(errno));
Dees_Troye34c1332013-02-06 19:13:00 +0000748 }
Dees_Troyce675462013-01-09 19:48:21 +0000749 }
750 }
751 closedir(d);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500752
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500753 if (!r) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500754 if (skipParent)
755 return 0;
756 else
757 r = rmdir(path.c_str());
758 }
Dees_Troyce675462013-01-09 19:48:21 +0000759 }
760 return r;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500761}
762
763int TWFunc::copy_file(string src, string dst, int mode) {
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400764 PartitionManager.Mount_By_Path(src, false);
765 PartitionManager.Mount_By_Path(dst, false);
766 if (!Path_Exists(src)) {
bigbifface7eec2020-08-30 11:18:39 -0400767 LOGINFO("Path %s does not exist. Unable to copy %s\n", src.c_str(), dst.c_str());
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400768 return -1;
769 }
bigbiffd3317052019-12-22 16:05:12 -0500770 std::ifstream srcfile(src.c_str(), ios::binary);
771 std::ofstream dstfile(dst.c_str(), ios::binary);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500772 dstfile << srcfile.rdbuf();
bigbiff bigbiffe3ad5342019-09-18 19:05:59 -0400773 if (!dstfile.bad()) {
774 LOGINFO("Copied file %s to %s\n", src.c_str(), dst.c_str());
775 }
776 else {
777 LOGINFO("Unable to copy file %s to %s\n", src.c_str(), dst.c_str());
778 return -1;
779 }
780
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500781 srcfile.close();
782 dstfile.close();
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500783 if (chmod(dst.c_str(), mode) != 0)
784 return -1;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500785 return 0;
786}
Dees_Troy3ee47bc2013-01-25 21:47:37 +0000787
788unsigned int TWFunc::Get_D_Type_From_Stat(string Path) {
789 struct stat st;
790
791 stat(Path.c_str(), &st);
792 if (st.st_mode & S_IFDIR)
793 return DT_DIR;
794 else if (st.st_mode & S_IFBLK)
795 return DT_BLK;
796 else if (st.st_mode & S_IFCHR)
797 return DT_CHR;
798 else if (st.st_mode & S_IFIFO)
799 return DT_FIFO;
800 else if (st.st_mode & S_IFLNK)
801 return DT_LNK;
802 else if (st.st_mode & S_IFREG)
803 return DT_REG;
804 else if (st.st_mode & S_IFSOCK)
805 return DT_SOCK;
806 return DT_UNKNOWN;
Dees_Troye34c1332013-02-06 19:13:00 +0000807}
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500808
809int TWFunc::read_file(string fn, string& results) {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200810 ifstream file;
811 file.open(fn.c_str(), ios::in);
812
813 if (file.is_open()) {
814 file >> results;
815 file.close();
816 return 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500817 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200818
819 LOGINFO("Cannot find file %s\n", fn.c_str());
820 return -1;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500821}
822
823int TWFunc::read_file(string fn, vector<string>& results) {
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500824 ifstream file;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500825 string line;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500826 file.open(fn.c_str(), ios::in);
827 if (file.is_open()) {
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500828 while (getline(file, line))
829 results.push_back(line);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500830 file.close();
831 return 0;
832 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000833 LOGINFO("Cannot find file %s\n", fn.c_str());
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500834 return -1;
835}
836
xNUTxe85f02d2014-07-18 01:30:58 +0200837int TWFunc::read_file(string fn, uint64_t& results) {
838 ifstream file;
839 file.open(fn.c_str(), ios::in);
840
841 if (file.is_open()) {
842 file >> results;
843 file.close();
844 return 0;
845 }
846
847 LOGINFO("Cannot find file %s\n", fn.c_str());
848 return -1;
849}
850
Ethan Yonker6e8c27a2016-12-22 17:55:57 -0600851int TWFunc::write_to_file(const string& fn, const string& line) {
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500852 FILE *file;
853 file = fopen(fn.c_str(), "w");
854 if (file != NULL) {
855 fwrite(line.c_str(), line.size(), 1, file);
856 fclose(file);
857 return 0;
858 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000859 LOGINFO("Cannot find file %s\n", fn.c_str());
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500860 return -1;
861}
862
Dees_Troy83bd4832013-05-04 12:39:56 +0000863bool TWFunc::Try_Decrypting_Backup(string Restore_Path, string Password) {
864 DIR* d;
865
866 string Filename;
867 Restore_Path += "/";
868 d = opendir(Restore_Path.c_str());
869 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500870 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Path)(strerror(errno)));
Dees_Troy83bd4832013-05-04 12:39:56 +0000871 return false;
872 }
873
874 struct dirent* de;
875 while ((de = readdir(d)) != NULL) {
876 Filename = Restore_Path;
877 Filename += de->d_name;
bigbiffce8f83c2015-12-12 18:30:21 -0500878 if (TWFunc::Get_File_Type(Filename) == ENCRYPTED) {
Dees_Troy83bd4832013-05-04 12:39:56 +0000879 if (TWFunc::Try_Decrypting_File(Filename, Password) < 2) {
880 DataManager::SetValue("tw_restore_password", ""); // Clear the bad password
881 DataManager::SetValue("tw_restore_display", ""); // Also clear the display mask
882 closedir(d);
883 return false;
884 }
885 }
886 }
887 closedir(d);
888 return true;
889}
890
Dees Troyb21cc642013-09-10 17:36:41 +0000891string TWFunc::Get_Current_Date() {
892 string Current_Date;
893 time_t seconds = time(0);
894 struct tm *t = localtime(&seconds);
895 char timestamp[255];
896 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);
897 Current_Date = timestamp;
898 return Current_Date;
899}
900
Ethan Yonkerb5557892014-02-07 21:43:20 -0600901string TWFunc::System_Property_Get(string Prop_Name) {
Chaosmaster65633a42020-02-05 15:24:09 +0100902 return System_Property_Get(Prop_Name, PartitionManager, PartitionManager.Get_Android_Root_Path());
903}
904
905string TWFunc::System_Property_Get(string Prop_Name, TWPartitionManager &PartitionManager, string Mount_Point) {
906 bool mount_state = PartitionManager.Is_Mounted_By_Path(Mount_Point);
Dees Troyb21cc642013-09-10 17:36:41 +0000907 std::vector<string> buildprop;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600908 string propvalue;
Chaosmaster65633a42020-02-05 15:24:09 +0100909 if (!PartitionManager.Mount_By_Path(Mount_Point, true))
Ethan Yonkerb5557892014-02-07 21:43:20 -0600910 return propvalue;
Chaosmaster65633a42020-02-05 15:24:09 +0100911 string prop_file = Mount_Point + "/build.prop";
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600912 if (!TWFunc::Path_Exists(prop_file))
Chaosmaster65633a42020-02-05 15:24:09 +0100913 prop_file = Mount_Point + "/system/build.prop"; // for devices with system as a root file system (e.g. Pixel)
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600914 if (TWFunc::read_file(prop_file, buildprop) != 0) {
Captain Throwback9d6feb52018-07-27 10:05:24 -0400915 LOGINFO("Unable to open build.prop for getting '%s'.\n", Prop_Name.c_str());
Vojtech Boceka2e70162013-09-17 17:05:10 +0200916 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
Dees Troyb21cc642013-09-10 17:36:41 +0000917 if (!mount_state)
Chaosmaster65633a42020-02-05 15:24:09 +0100918 PartitionManager.UnMount_By_Path(Mount_Point, false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600919 return propvalue;
Dees Troyb21cc642013-09-10 17:36:41 +0000920 }
921 int line_count = buildprop.size();
922 int index;
923 size_t start_pos = 0, end_pos;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600924 string propname;
Dees Troyb21cc642013-09-10 17:36:41 +0000925 for (index = 0; index < line_count; index++) {
926 end_pos = buildprop.at(index).find("=", start_pos);
927 propname = buildprop.at(index).substr(start_pos, end_pos);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600928 if (propname == Prop_Name) {
Dees Troyb21cc642013-09-10 17:36:41 +0000929 propvalue = buildprop.at(index).substr(end_pos + 1, buildprop.at(index).size());
Ethan Yonkerb5557892014-02-07 21:43:20 -0600930 if (!mount_state)
Chaosmaster65633a42020-02-05 15:24:09 +0100931 PartitionManager.UnMount_By_Path(Mount_Point, false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600932 return propvalue;
Dees Troyb21cc642013-09-10 17:36:41 +0000933 }
934 }
Dees Troyb21cc642013-09-10 17:36:41 +0000935 if (!mount_state)
Chaosmaster65633a42020-02-05 15:24:09 +0100936 PartitionManager.UnMount_By_Path(Mount_Point, false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600937 return propvalue;
938}
939
940void TWFunc::Auto_Generate_Backup_Name() {
941 string propvalue = System_Property_Get("ro.build.display.id");
942 if (propvalue.empty()) {
943 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
944 return;
945 }
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -0400946 else {
947 //remove periods from build display so it doesn't confuse the extension code
948 propvalue.erase(remove(propvalue.begin(), propvalue.end(), '.'), propvalue.end());
949 }
Ethan Yonkerb5557892014-02-07 21:43:20 -0600950 string Backup_Name = Get_Current_Date();
bigbiff74a6d0d2015-02-14 20:49:44 -0500951 Backup_Name += "_" + propvalue;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600952 if (Backup_Name.size() > MAX_BACKUP_NAME_LEN)
953 Backup_Name.resize(MAX_BACKUP_NAME_LEN);
954 // Trailing spaces cause problems on some file systems, so remove them
955 string space_check, space = " ";
956 space_check = Backup_Name.substr(Backup_Name.size() - 1, 1);
957 while (space_check == space) {
958 Backup_Name.resize(Backup_Name.size() - 1);
959 space_check = Backup_Name.substr(Backup_Name.size() - 1, 1);
960 }
bigbiff74a6d0d2015-02-14 20:49:44 -0500961 replace(Backup_Name.begin(), Backup_Name.end(), ' ', '_');
Ethan Yonker53796e72019-01-11 22:49:52 -0600962 if (PartitionManager.Check_Backup_Name(Backup_Name, false, true) != 0) {
963 LOGINFO("Auto generated backup name '%s' is not valid, using date instead.\n", Backup_Name.c_str());
Ethan Yonker92d48e02014-02-26 12:05:55 -0600964 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
Ethan Yonker53796e72019-01-11 22:49:52 -0600965 } else {
966 DataManager::SetValue(TW_BACKUP_NAME, Backup_Name);
Ethan Yonker92d48e02014-02-26 12:05:55 -0600967 }
Vojtech Bocek05534202013-09-11 08:11:56 +0200968}
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100969
nkk7198fc3992017-12-16 16:26:42 +0200970void TWFunc::Fixup_Time_On_Boot(const string& time_paths /* = "" */)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100971{
972#ifdef QCOM_RTC_FIX
nkk7198fc3992017-12-16 16:26:42 +0200973 static bool fixed = false;
974 if (fixed)
975 return;
xNUTxe85f02d2014-07-18 01:30:58 +0200976
977 LOGINFO("TWFunc::Fixup_Time: Pre-fix date and time: %s\n", TWFunc::Get_Current_Date().c_str());
978
979 struct timeval tv;
980 uint64_t offset = 0;
981 std::string sepoch = "/sys/class/rtc/rtc0/since_epoch";
982
983 if (TWFunc::read_file(sepoch, offset) == 0) {
984
985 LOGINFO("TWFunc::Fixup_Time: Setting time offset from file %s\n", sepoch.c_str());
986
987 tv.tv_sec = offset;
988 tv.tv_usec = 0;
989 settimeofday(&tv, NULL);
990
991 gettimeofday(&tv, NULL);
992
Phoenix59146b05f22018-02-03 06:41:08 +0000993 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 +0200994
995 LOGINFO("TWFunc::Fixup_Time: Date and time corrected: %s\n", TWFunc::Get_Current_Date().c_str());
nkk7198fc3992017-12-16 16:26:42 +0200996 fixed = true;
xNUTxe85f02d2014-07-18 01:30:58 +0200997 return;
998
999 }
1000
1001 } else {
1002
1003 LOGINFO("TWFunc::Fixup_Time: opening %s failed\n", sepoch.c_str());
1004
1005 }
1006
Ethan Yonker9132d912015-02-02 10:32:49 -06001007 LOGINFO("TWFunc::Fixup_Time: will attempt to use the ats files now.\n");
xNUTxe85f02d2014-07-18 01:30:58 +02001008
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001009 // Devices with Qualcomm Snapdragon 800 do some shenanigans with RTC.
1010 // They never set it, it just ticks forward from 1970-01-01 00:00,
1011 // and then they have files /data/system/time/ats_* with 64bit offset
1012 // in miliseconds which, when added to the RTC, gives the correct time.
1013 // So, the time is: (offset_from_ats + value_from_RTC)
1014 // There are multiple ats files, they are for different systems? Bases?
1015 // Like, ats_1 is for modem and ats_2 is for TOD (time of day?).
1016 // Look at file time_genoff.h in CodeAurora, qcom-opensource/time-services
1017
nkk7198fc3992017-12-16 16:26:42 +02001018 std::vector<std::string> paths; // space separated list of paths
1019 if (time_paths.empty()) {
Mauronofrio Matarrese2dab70d2019-03-05 02:22:26 +01001020 paths = Split_String("/data/system/time/ /data/time/ /data/vendor/time/", " ");
nkk7198fc3992017-12-16 16:26:42 +02001021 if (!PartitionManager.Mount_By_Path("/data", false))
1022 return;
1023 } else {
1024 // When specific path(s) are used, Fixup_Time needs those
1025 // partitions to already be mounted!
1026 paths = Split_String(time_paths, " ");
1027 }
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001028
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001029 FILE *f;
xNUTxe85f02d2014-07-18 01:30:58 +02001030 offset = 0;
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001031 struct dirent *dt;
1032 std::string ats_path;
1033
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001034 // Prefer ats_2, it seems to be the one we want according to logcat on hammerhead
1035 // - it is the one for ATS_TOD (time of day?).
1036 // However, I never saw a device where the offset differs between ats files.
nkk7198fc3992017-12-16 16:26:42 +02001037 for (size_t i = 0; i < paths.size(); ++i)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001038 {
nkk7198fc3992017-12-16 16:26:42 +02001039 DIR *d = opendir(paths[i].c_str());
Matt Mowera8a89d12016-12-30 18:10:37 -06001040 if (!d)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001041 continue;
1042
Matt Mowera8a89d12016-12-30 18:10:37 -06001043 while ((dt = readdir(d)))
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001044 {
Matt Mowera8a89d12016-12-30 18:10:37 -06001045 if (dt->d_type != DT_REG || strncmp(dt->d_name, "ats_", 4) != 0)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001046 continue;
1047
Matt Mowera8a89d12016-12-30 18:10:37 -06001048 if (ats_path.empty() || strcmp(dt->d_name, "ats_2") == 0)
nkk7198fc3992017-12-16 16:26:42 +02001049 ats_path = paths[i] + dt->d_name;
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001050 }
1051
1052 closedir(d);
1053 }
1054
nkk7198fc3992017-12-16 16:26:42 +02001055 if (ats_path.empty()) {
xNUTxe85f02d2014-07-18 01:30:58 +02001056 LOGINFO("TWFunc::Fixup_Time: no ats files found, leaving untouched!\n");
nkk7198fc3992017-12-16 16:26:42 +02001057 } else if ((f = fopen(ats_path.c_str(), "r")) == NULL) {
Dees Troy3e254b92014-03-06 20:24:54 +00001058 LOGINFO("TWFunc::Fixup_Time: failed to open file %s\n", ats_path.c_str());
nkk7198fc3992017-12-16 16:26:42 +02001059 } else if (fread(&offset, sizeof(offset), 1, f) != 1) {
Dees Troy3e254b92014-03-06 20:24:54 +00001060 LOGINFO("TWFunc::Fixup_Time: failed load uint64 from file %s\n", ats_path.c_str());
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001061 fclose(f);
nkk7198fc3992017-12-16 16:26:42 +02001062 } else {
1063 fclose(f);
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001064
nkk7198fc3992017-12-16 16:26:42 +02001065 LOGINFO("TWFunc::Fixup_Time: Setting time offset from file %s, offset %llu\n", ats_path.c_str(), (unsigned long long) offset);
1066 DataManager::SetValue("tw_qcom_ats_offset", (unsigned long long) offset, 1);
1067 fixed = true;
1068 }
1069
1070 if (!fixed) {
1071 // Failed to get offset from ats file, check twrp settings
1072 unsigned long long value;
1073 if (DataManager::GetValue("tw_qcom_ats_offset", value) < 0) {
1074 return;
1075 } else {
1076 offset = (uint64_t) value;
1077 LOGINFO("TWFunc::Fixup_Time: Setting time offset from twrp setting file, offset %llu\n", (unsigned long long) offset);
1078 // Do not consider the settings file as a definitive answer, keep fixed=false so next run will try ats files again
1079 }
1080 }
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001081
1082 gettimeofday(&tv, NULL);
1083
1084 tv.tv_sec += offset/1000;
Phoenix591e444d112018-02-03 07:23:54 +00001085#ifdef TW_CLOCK_OFFSET
1086// Some devices are even quirkier and have ats files that are offset from the actual time
1087 tv.tv_sec = tv.tv_sec + TW_CLOCK_OFFSET;
1088#endif
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001089 tv.tv_usec += (offset%1000)*1000;
1090
Matt Mowera8a89d12016-12-30 18:10:37 -06001091 while (tv.tv_usec >= 1000000)
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001092 {
1093 ++tv.tv_sec;
1094 tv.tv_usec -= 1000000;
1095 }
1096
1097 settimeofday(&tv, NULL);
xNUTxe85f02d2014-07-18 01:30:58 +02001098
1099 LOGINFO("TWFunc::Fixup_Time: Date and time corrected: %s\n", TWFunc::Get_Current_Date().c_str());
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +01001100#endif
1101}
Ethan Yonkeraf2897c2014-02-10 13:07:14 -06001102
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001103std::vector<std::string> TWFunc::Split_String(const std::string& str, const std::string& delimiter, bool removeEmpty)
1104{
1105 std::vector<std::string> res;
1106 size_t idx = 0, idx_last = 0;
1107
Matt Mowera8a89d12016-12-30 18:10:37 -06001108 while (idx < str.size())
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001109 {
1110 idx = str.find_first_of(delimiter, idx_last);
Matt Mowera8a89d12016-12-30 18:10:37 -06001111 if (idx == std::string::npos)
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001112 idx = str.size();
1113
Matt Mowera8a89d12016-12-30 18:10:37 -06001114 if (idx-idx_last != 0 || !removeEmpty)
Vojtech Bocek0b7fe502014-03-13 17:36:52 +01001115 res.push_back(str.substr(idx_last, idx-idx_last));
1116
1117 idx_last = idx + delimiter.size();
1118 }
1119
1120 return res;
1121}
1122
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001123bool TWFunc::Create_Dir_Recursive(const std::string& path, mode_t mode, uid_t uid, gid_t gid)
1124{
1125 std::vector<std::string> parts = Split_String(path, "/");
1126 std::string cur_path;
1127 struct stat info;
Matt Mowera8a89d12016-12-30 18:10:37 -06001128 for (size_t i = 0; i < parts.size(); ++i)
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001129 {
1130 cur_path += "/" + parts[i];
Matt Mowera8a89d12016-12-30 18:10:37 -06001131 if (stat(cur_path.c_str(), &info) < 0 || !S_ISDIR(info.st_mode))
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001132 {
Matt Mowera8a89d12016-12-30 18:10:37 -06001133 if (mkdir(cur_path.c_str(), mode) < 0)
Vojtech Bocek03fd6c52014-03-13 18:46:34 +01001134 return false;
1135 chown(cur_path.c_str(), uid, gid);
1136 }
1137 }
1138 return true;
1139}
1140
xNUTxe85f02d2014-07-18 01:30:58 +02001141int TWFunc::Set_Brightness(std::string brightness_value)
1142{
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001143 int result = -1;
1144 std::string secondary_brightness_file;
xNUTxe85f02d2014-07-18 01:30:58 +02001145
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001146 if (DataManager::GetIntValue("tw_has_brightnesss_file")) {
xNUTxe85f02d2014-07-18 01:30:58 +02001147 LOGINFO("TWFunc::Set_Brightness: Setting brightness control to %s\n", brightness_value.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001148 result = TWFunc::write_to_file(DataManager::GetStrValue("tw_brightness_file"), brightness_value);
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001149 DataManager::GetValue("tw_secondary_brightness_file", secondary_brightness_file);
1150 if (!secondary_brightness_file.empty()) {
1151 LOGINFO("TWFunc::Set_Brightness: Setting secondary brightness control to %s\n", brightness_value.c_str());
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001152 TWFunc::write_to_file(secondary_brightness_file, brightness_value);
xNUTxe85f02d2014-07-18 01:30:58 +02001153 }
xNUTxe85f02d2014-07-18 01:30:58 +02001154 }
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001155 return result;
xNUTxe85f02d2014-07-18 01:30:58 +02001156}
1157
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001158bool TWFunc::Toggle_MTP(bool enable) {
1159#ifdef TW_HAS_MTP
1160 static int was_enabled = false;
1161
1162 if (enable && was_enabled) {
1163 if (!PartitionManager.Enable_MTP())
1164 PartitionManager.Disable_MTP();
1165 } else {
1166 was_enabled = DataManager::GetIntValue("tw_mtp_enabled");
1167 PartitionManager.Disable_MTP();
1168 usleep(500);
1169 }
1170 return was_enabled;
1171#else
1172 return false;
1173#endif
1174}
1175
Tom Hite5a926722014-09-15 01:31:03 +00001176void TWFunc::SetPerformanceMode(bool mode) {
1177 if (mode) {
1178 property_set("recovery.perf.mode", "1");
1179 } else {
1180 property_set("recovery.perf.mode", "0");
1181 }
1182 // Some time for events to catch up to init handlers
1183 usleep(500000);
1184}
1185
Jenkins1710bf22014-10-02 20:22:21 -04001186std::string TWFunc::to_string(unsigned long value) {
1187 std::ostringstream os;
1188 os << value;
1189 return os.str();
1190}
1191
Ethan Yonker9132d912015-02-02 10:32:49 -06001192void TWFunc::Disable_Stock_Recovery_Replace(void) {
Captain Throwback9d6feb52018-07-27 10:05:24 -04001193 if (PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), false)) {
Ethan Yonker9132d912015-02-02 10:32:49 -06001194 // Disable flashing of stock recovery
1195 if (TWFunc::Path_Exists("/system/recovery-from-boot.p")) {
1196 rename("/system/recovery-from-boot.p", "/system/recovery-from-boot.bak");
Ethan Yonker74db1572015-10-28 12:44:49 -05001197 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 -06001198 sync();
1199 }
Captain Throwback9d6feb52018-07-27 10:05:24 -04001200 PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), false);
Ethan Yonker9132d912015-02-02 10:32:49 -06001201 }
1202}
1203
Ethan Yonker483e9f42016-01-11 22:21:18 -06001204unsigned long long TWFunc::IOCTL_Get_Block_Size(const char* block_device) {
1205 unsigned long block_device_size;
1206 int ret = 0;
1207
1208 int fd = open(block_device, O_RDONLY);
1209 if (fd < 0) {
1210 LOGINFO("Find_Partition_Size: Failed to open '%s', (%s)\n", block_device, strerror(errno));
1211 } else {
1212 ret = ioctl(fd, BLKGETSIZE, &block_device_size);
1213 close(fd);
1214 if (ret) {
1215 LOGINFO("Find_Partition_Size: ioctl error: (%s)\n", strerror(errno));
1216 } else {
1217 return (unsigned long long)(block_device_size) * 512LLU;
1218 }
1219 }
1220 return 0;
1221}
1222
bigbiff bigbiffbad332a2016-07-29 21:18:13 -04001223void TWFunc::copy_kernel_log(string curr_storage) {
1224 std::string dmesgDst = curr_storage + "/dmesg.log";
1225 std::string dmesgCmd = "/sbin/dmesg";
1226
1227 std::string result;
bigbiff56b02eb2020-07-06 20:24:34 -04001228 Exec_Cmd(dmesgCmd, result, false);
Ethan Yonker6e8c27a2016-12-22 17:55:57 -06001229 write_to_file(dmesgDst, result);
bigbiff bigbiffbad332a2016-07-29 21:18:13 -04001230 gui_msg(Msg("copy_kernel_log=Copied kernel log to {1}")(dmesgDst));
1231 tw_set_default_metadata(dmesgDst.c_str());
1232}
bigbiff bigbiff19fb79c2016-09-05 21:04:51 -04001233
1234bool TWFunc::isNumber(string strtocheck) {
1235 int num = 0;
1236 std::istringstream iss(strtocheck);
1237
1238 if (!(iss >> num).fail())
1239 return true;
1240 else
1241 return false;
1242}
1243
1244int TWFunc::stream_adb_backup(string &Restore_Name) {
1245 string cmd = "/sbin/bu --twrp stream " + Restore_Name;
1246 LOGINFO("stream_adb_backup: %s\n", cmd.c_str());
1247 int ret = TWFunc::Exec_Cmd(cmd);
1248 if (ret != 0)
1249 return -1;
1250 return ret;
1251}
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001252
bigbiff349ea552020-06-19 16:07:38 -04001253std::string TWFunc::get_log_dir() {
1254 if (PartitionManager.Find_Partition_By_Path(CACHE_LOGS_DIR) == NULL) {
1255 if (PartitionManager.Find_Partition_By_Path(DATA_LOGS_DIR) == NULL) {
bigbifface7eec2020-08-30 11:18:39 -04001256 LOGINFO("Unable to find a directory to store TWRP logs.");
1257 return "";
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -04001258 } else {
bigbiff349ea552020-06-19 16:07:38 -04001259 return DATA_LOGS_DIR;
bigbiff bigbiffe4bdb152019-03-23 18:33:17 -04001260 }
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001261 }
1262 else {
bigbiff349ea552020-06-19 16:07:38 -04001263 return CACHE_LOGS_DIR;
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001264 }
1265}
1266
1267void TWFunc::check_selinux_support() {
1268 if (TWFunc::Path_Exists("/prebuilt_file_contexts")) {
1269 if (TWFunc::Path_Exists("/file_contexts")) {
1270 printf("Renaming regular /file_contexts -> /file_contexts.bak\n");
1271 rename("/file_contexts", "/file_contexts.bak");
1272 }
1273 printf("Moving /prebuilt_file_contexts -> /file_contexts\n");
1274 rename("/prebuilt_file_contexts", "/file_contexts");
1275 }
1276 struct selinux_opt selinux_options[] = {
1277 { SELABEL_OPT_PATH, "/file_contexts" }
1278 };
1279 selinux_handle = selabel_open(SELABEL_CTX_FILE, selinux_options, 1);
1280 if (!selinux_handle)
1281 printf("No file contexts for SELinux\n");
1282 else
1283 printf("SELinux contexts loaded from /file_contexts\n");
1284 { // Check to ensure SELinux can be supported by the kernel
1285 char *contexts = NULL;
bigbiff349ea552020-06-19 16:07:38 -04001286 std::string cacheDir = TWFunc::get_log_dir();
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001287 std::string se_context_check = cacheDir + "recovery/";
1288 int ret = 0;
1289
bigbiff349ea552020-06-19 16:07:38 -04001290 if (cacheDir == CACHE_LOGS_DIR) {
1291 PartitionManager.Mount_By_Path(CACHE_LOGS_DIR, false);
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001292 }
1293 if (TWFunc::Path_Exists(se_context_check)) {
1294 ret = lgetfilecon(se_context_check.c_str(), &contexts);
Makornthawat Emeryabc299c2019-03-29 13:45:22 +00001295 if (ret < 0) {
bigbiff bigbiff19874f12019-01-08 20:06:57 -05001296 LOGINFO("Could not check %s SELinux contexts, using /sbin/teamwin instead which may be inaccurate.\n", se_context_check.c_str());
1297 lgetfilecon("/sbin/teamwin", &contexts);
1298 }
1299 }
1300 if (ret < 0) {
1301 gui_warn("no_kernel_selinux=Kernel does not have support for reading SELinux contexts.");
1302 } else {
1303 free(contexts);
1304 gui_msg("full_selinux=Full SELinux support is present.");
1305 }
1306 }
1307}
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05001308
1309bool TWFunc::Is_TWRP_App_In_System() {
Captain Throwbackcc9746b2020-12-21 11:28:34 -05001310 bool is_system_mounted = true;
1311 if(!PartitionManager.Is_Mounted_By_Path(PartitionManager.Get_Android_Root_Path())) {
1312 is_system_mounted = false;
1313 PartitionManager.Mount_By_Path(PartitionManager.Get_Android_Root_Path(), false);
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05001314 }
Captain Throwbackcc9746b2020-12-21 11:28:34 -05001315 string base_path = PartitionManager.Get_Android_Root_Path();
1316 if (TWFunc::Path_Exists(PartitionManager.Get_Android_Root_Path() + "/system"))
1317 base_path += "/system"; // For devices with system as a root file system (e.g. Pixel)
1318 string install_path = base_path + "/priv-app";
1319 if (!TWFunc::Path_Exists(install_path))
1320 install_path = base_path + "/app";
1321 install_path += "/twrpapp";
1322 if (TWFunc::Path_Exists(install_path)) {
1323 LOGINFO("App found at '%s'\n", install_path.c_str());
1324 DataManager::SetValue("tw_app_installed_in_system", 1);
1325 return true;
1326 }
1327 if (!is_system_mounted)
1328 PartitionManager.UnMount_By_Path(PartitionManager.Get_Android_Root_Path(), false);
Ethan Yonker76bbd3a2019-05-10 10:50:04 -05001329 DataManager::SetValue("tw_app_installed_in_system", 0);
1330 return false;
1331}
Chaosmaster461e39f2020-02-07 01:48:13 +01001332
epicX9d930a22020-12-29 00:39:36 +05301333void TWFunc::checkforapp(){
1334
1335 string sdkverstr = System_Property_Get("ro.build.version.sdk");
1336 int sdkver = 0;
1337 if (!sdkverstr.empty()) {
1338 sdkver = atoi(sdkverstr.c_str());
1339 }
1340 if (sdkver <= 13) {
1341 if (sdkver == 0)
1342 LOGINFO("Unable to read sdk version from build prop\n");
1343 else
1344 LOGINFO("SDK version too low for TWRP app (%i < 14)\n", sdkver);
1345 DataManager::SetValue("tw_app_install_status", 1); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1346 goto exit;
1347 }
1348 if (Is_TWRP_App_In_System()) {
1349 DataManager::SetValue("tw_app_install_status", 2); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1350 goto exit;
1351 }
1352 if (PartitionManager.Mount_By_Path("/data", false)) {
1353 const char parent_path[] = "/data/app";
1354 const char app_prefix[] = "me.twrp.twrpapp-";
1355 DIR *d = opendir(parent_path);
1356 if (d) {
1357 struct dirent *p;
1358 while ((p = readdir(d))) {
1359 if (p->d_type != DT_DIR || strlen(p->d_name) < strlen(app_prefix) || strncmp(p->d_name, app_prefix, strlen(app_prefix)))
1360 continue;
1361 closedir(d);
1362 LOGINFO("App found at '%s/%s'\n", parent_path, p->d_name);
1363 DataManager::SetValue("tw_app_install_status", 2); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1364 goto exit;
1365 }
1366 closedir(d);
1367 }
1368 } else {
1369 LOGINFO("Data partition cannot be mounted during app check\n");
1370 DataManager::SetValue("tw_app_install_status", 2); // 0 = no status, 1 = not installed, 2 = already installed or do not install
1371 }
1372
1373 LOGINFO("App not installed\n");
1374 DataManager::SetValue("tw_app_install_status", 1); // 0 = no status, 1 = not installed, 2 = already installed
1375exit:
1376 return;
1377
1378}
1379
Chaosmaster461e39f2020-02-07 01:48:13 +01001380int TWFunc::Property_Override(string Prop_Name, string Prop_Value) {
1381#ifdef TW_INCLUDE_LIBRESETPROP
1382 return setprop(Prop_Name.c_str(), Prop_Value.c_str(), false);
1383#else
1384 return -2;
1385#endif
1386}
1387
bigbiffa2bd7b72020-05-07 21:45:34 -04001388bool TWFunc::Get_Encryption_Policy(ext4_encryption_policy &policy, std::string path) {
bigbifff62d2492020-05-20 10:15:34 -04001389#ifdef TW_INCLUDE_FBE
bigbiffa2bd7b72020-05-07 21:45:34 -04001390 if (!TWFunc::Path_Exists(path)) {
1391 LOGERR("Unable to find %s to get policy\n", path.c_str());
1392 return false;
1393 }
1394 if (!e4crypt_policy_get_struct(path.c_str(), &policy)) {
1395 LOGERR("No policy set for path %s\n", path.c_str());
1396 return false;
1397 }
bigbifff62d2492020-05-20 10:15:34 -04001398#endif
bigbiffa2bd7b72020-05-07 21:45:34 -04001399 return true;
1400}
1401
1402bool TWFunc::Set_Encryption_Policy(std::string path, const ext4_encryption_policy &policy) {
bigbifff62d2492020-05-20 10:15:34 -04001403#ifdef TW_INCLUDE_FBE
bigbiffa2bd7b72020-05-07 21:45:34 -04001404 if (!TWFunc::Path_Exists(path)) {
1405 LOGERR("unable to find %s to set policy\n", path.c_str());
1406 return false;
1407 }
1408 char binary_policy[EXT4_KEY_DESCRIPTOR_SIZE];
1409 char policy_hex[EXT4_KEY_DESCRIPTOR_SIZE_HEX];
1410 policy_to_hex(binary_policy, policy_hex);
1411 if (!e4crypt_policy_set_struct(path.c_str(), &policy)) {
1412 LOGERR("unable to set policy for path: %s\n", path.c_str());
1413 return false;
1414 }
bigbifff62d2492020-05-20 10:15:34 -04001415#endif
bigbiffa2bd7b72020-05-07 21:45:34 -04001416 return true;
1417}
epicX98053c32021-01-04 13:01:31 +05301418
1419string TWFunc::Check_For_TwrpFolder(){
1420 string oldFolder = "";
1421 vector<string> customTWRPFolders;
1422 string mainPath = DataManager::GetCurrentStoragePath();
1423 DIR* d;
1424 struct dirent* de;
1425
epicXfb610382021-03-01 00:02:57 +05301426 if (DataManager::GetIntValue(TW_IS_ENCRYPTED)) {
epicX98053c32021-01-04 13:01:31 +05301427 goto exit;
1428 }
1429
1430
1431 d = opendir(mainPath.c_str());
1432 if (d == NULL) {
1433 goto exit;
1434 }
1435
1436 while ((de = readdir(d)) != NULL) {
1437 string name = de->d_name;
1438 string fullPath = mainPath + '/' + name;
1439 unsigned char type = de->d_type;
1440
epicXfb610382021-03-01 00:02:57 +05301441 if (name == "." || name == "..") continue;
epicX98053c32021-01-04 13:01:31 +05301442
epicXfb610382021-03-01 00:02:57 +05301443 if (type == DT_UNKNOWN) {
epicX98053c32021-01-04 13:01:31 +05301444 type = Get_D_Type_From_Stat(fullPath);
1445 }
1446
epicXfb610382021-03-01 00:02:57 +05301447 if (type == DT_DIR && Path_Exists(fullPath + '/' + TW_SETTINGS_FILE)) {
1448 if ('/' + name == TW_DEFAULT_RECOVERY_FOLDER) {
epicX98053c32021-01-04 13:01:31 +05301449 oldFolder = name;
epicXfb610382021-03-01 00:02:57 +05301450 } else {
epicX98053c32021-01-04 13:01:31 +05301451 customTWRPFolders.push_back(name);
1452 }
1453 }
1454 }
1455
1456 closedir(d);
1457
epicXfb610382021-03-01 00:02:57 +05301458 if (oldFolder == "" && customTWRPFolders.empty()) {
epicX98053c32021-01-04 13:01:31 +05301459 LOGINFO("No recovery folder found. Using default folder.\n");
1460 goto exit;
epicXfb610382021-03-01 00:02:57 +05301461 } else if (customTWRPFolders.empty()) {
epicX98053c32021-01-04 13:01:31 +05301462 LOGINFO("No custom recovery folder found. Using TWRP as default.\n");
1463 goto exit;
epicXfb610382021-03-01 00:02:57 +05301464 } else {
1465 if (customTWRPFolders.size() > 1) {
epicX98053c32021-01-04 13:01:31 +05301466 LOGINFO("More than one custom recovery folder found. Using first one from the list.\n");
epicXfb610382021-03-01 00:02:57 +05301467 } else {
epicX98053c32021-01-04 13:01:31 +05301468 LOGINFO("One custom recovery folder found.\n");
1469 }
1470 string customPath = '/' + customTWRPFolders.at(0);
1471
epicXfb610382021-03-01 00:02:57 +05301472 if (Path_Exists(mainPath + TW_DEFAULT_RECOVERY_FOLDER)) {
epicX98053c32021-01-04 13:01:31 +05301473 string oldBackupFolder = mainPath + TW_DEFAULT_RECOVERY_FOLDER + "/BACKUPS/" + DataManager::GetStrValue("device_id");
1474 string newBackupFolder = mainPath + customPath + "/BACKUPS/" + DataManager::GetStrValue("device_id");
1475
epicXfb610382021-03-01 00:02:57 +05301476 if (Path_Exists(oldBackupFolder)) {
epicX98053c32021-01-04 13:01:31 +05301477 vector<string> backups;
1478 d = opendir(oldBackupFolder.c_str());
1479
1480 if (d != NULL) {
1481 while ((de = readdir(d)) != NULL) {
1482 string name = de->d_name;
1483 unsigned char type = de->d_type;
1484
epicXfb610382021-03-01 00:02:57 +05301485 if (name == "." || name == "..") continue;
epicX98053c32021-01-04 13:01:31 +05301486
epicXfb610382021-03-01 00:02:57 +05301487 if (type == DT_UNKNOWN) {
epicX98053c32021-01-04 13:01:31 +05301488 type = Get_D_Type_From_Stat(mainPath + '/' + name);
1489 }
1490
epicXfb610382021-03-01 00:02:57 +05301491 if (type == DT_DIR) {
epicX98053c32021-01-04 13:01:31 +05301492 backups.push_back(name);
1493 }
1494 }
1495 closedir(d);
1496 }
1497
epicXfb610382021-03-01 00:02:57 +05301498 for (auto it = backups.begin(); it != backups.end(); it++) {
epicX98053c32021-01-04 13:01:31 +05301499 Exec_Cmd("mv -f \"" + oldBackupFolder + '/' + *it + "\" \"" + newBackupFolder + '/' + *it + (Path_Exists(newBackupFolder + '/' + *it) ? "_new\"" : "\""));
1500 }
1501 }
1502 Exec_Cmd("rm -rf \"" + mainPath + TW_DEFAULT_RECOVERY_FOLDER + '\"');
1503 }
1504
1505 return customPath;
1506 }
1507
1508exit:
1509 return TW_DEFAULT_RECOVERY_FOLDER;
1510}
Ethan Yonkeraf2897c2014-02-10 13:07:14 -06001511#endif // ndef BUILD_TWRPTAR_MAIN