blob: 92d3a3b9d3838d35306210931128bc17fa4b47cd [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>
bigbiff74a6d0d2015-02-14 20:49:44 -050038#include <algorithm>
Dees_Troy38bd7602012-09-14 13:33:53 -040039#include "twrp-functions.hpp"
Dees_Troy2673cec2013-04-02 20:22:16 +000040#include "twcommon.h"
Ethan Yonker472f5062016-02-25 13:47:30 -060041#include "gui/gui.hpp"
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060042#ifndef BUILD_TWRPTAR_MAIN
Dees_Troyb46a6842012-09-25 11:06:46 -040043#include "data.hpp"
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060044#include "partitions.hpp"
Dees_Troy3477d712012-09-27 15:44:01 -040045#include "variables.h"
Dees_Troy2673cec2013-04-02 20:22:16 +000046#include "bootloader.h"
Tom Hite5a926722014-09-15 01:31:03 +000047#include "cutils/properties.h"
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -050048#include "cutils/android_reboot.h"
49#include <sys/reboot.h>
Ethan Yonkeraf2897c2014-02-10 13:07:14 -060050#endif // ndef BUILD_TWRPTAR_MAIN
Dees_Troy83bd4832013-05-04 12:39:56 +000051#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
52 #include "openaes/inc/oaes_lib.h"
53#endif
Ethan Yonkerf1179622016-08-25 15:32:21 -050054#include "set_metadata.h"
Dees_Troy38bd7602012-09-14 13:33:53 -040055
Dees_Troyb05ddee2013-01-28 20:24:50 +000056extern "C" {
57 #include "libcrecovery/common.h"
58}
59
bigbiff bigbiff9c754052013-01-09 09:09:08 -050060/* Execute a command */
Vojtech Bocek05534202013-09-11 08:11:56 +020061int TWFunc::Exec_Cmd(const string& cmd, string &result) {
Dees_Troy29a06352013-08-24 12:06:47 +000062 FILE* exec;
63 char buffer[130];
64 int ret = 0;
65 exec = __popen(cmd.c_str(), "r");
66 if (!exec) return -1;
67 while(!feof(exec)) {
Dees_Troy29a06352013-08-24 12:06:47 +000068 if (fgets(buffer, 128, exec) != NULL) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -050069 result += buffer;
Dees_Troyb05ddee2013-01-28 20:24:50 +000070 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -050071 }
Dees_Troy29a06352013-08-24 12:06:47 +000072 ret = __pclose(exec);
73 return ret;
bigbiff bigbiff9c754052013-01-09 09:09:08 -050074}
75
Vojtech Bocek05534202013-09-11 08:11:56 +020076int TWFunc::Exec_Cmd(const string& cmd) {
77 pid_t pid;
78 int status;
79 switch(pid = fork())
80 {
81 case -1:
bigbiff bigbiff731df792014-02-20 18:26:13 -050082 LOGERR("Exec_Cmd(): vfork failed: %d!\n", errno);
Vojtech Bocek05534202013-09-11 08:11:56 +020083 return -1;
84 case 0: // child
85 execl("/sbin/sh", "sh", "-c", cmd.c_str(), NULL);
86 _exit(127);
87 break;
88 default:
89 {
90 if (TWFunc::Wait_For_Child(pid, &status, cmd) != 0)
91 return -1;
92 else
93 return 0;
94 }
95 }
96}
97
Dees_Troy38bd7602012-09-14 13:33:53 -040098// Returns "file.name" from a full /path/to/file.name
99string TWFunc::Get_Filename(string Path) {
100 size_t pos = Path.find_last_of("/");
101 if (pos != string::npos) {
102 string Filename;
103 Filename = Path.substr(pos + 1, Path.size() - pos - 1);
104 return Filename;
105 } else
106 return Path;
107}
108
109// Returns "/path/to/" from a full /path/to/file.name
110string TWFunc::Get_Path(string Path) {
111 size_t pos = Path.find_last_of("/");
112 if (pos != string::npos) {
113 string Pathonly;
114 Pathonly = Path.substr(0, pos + 1);
115 return Pathonly;
116 } else
117 return Path;
118}
119
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600120int TWFunc::Wait_For_Child(pid_t pid, int *status, string Child_Name) {
121 pid_t rc_pid;
122
123 rc_pid = waitpid(pid, status, 0);
124 if (rc_pid > 0) {
Vojtech Bocek0fdcbec2015-03-20 15:36:40 +0100125 if (WIFSIGNALED(*status)) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500126 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 -0600127 return -1;
Vojtech Bocek0fdcbec2015-03-20 15:36:40 +0100128 } else if (WEXITSTATUS(*status) == 0) {
129 LOGINFO("%s process ended with RC=%d\n", Child_Name.c_str(), WEXITSTATUS(*status)); // Success
130 } else {
Ethan Yonker74db1572015-10-28 12:44:49 -0500131 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 -0600132 return -1;
133 }
134 } else { // no PID returned
135 if (errno == ECHILD)
that2252d242015-04-03 22:33:04 +0200136 LOGERR("%s no child process exist\n", Child_Name.c_str());
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600137 else {
that2252d242015-04-03 22:33:04 +0200138 LOGERR("%s Unexpected error %d\n", Child_Name.c_str(), errno);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600139 return -1;
140 }
141 }
142 return 0;
143}
144
145bool TWFunc::Path_Exists(string Path) {
146 // Check to see if the Path exists
147 struct stat st;
148 if (stat(Path.c_str(), &st) != 0)
149 return false;
150 else
151 return true;
152}
153
bigbiffce8f83c2015-12-12 18:30:21 -0500154Archive_Type TWFunc::Get_File_Type(string fn) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600155 string::size_type i = 0;
156 int firstbyte = 0, secondbyte = 0;
157 char header[3];
158
159 ifstream f;
160 f.open(fn.c_str(), ios::in | ios::binary);
161 f.get(header, 3);
162 f.close();
163 firstbyte = header[i] & 0xff;
164 secondbyte = header[++i] & 0xff;
165
166 if (firstbyte == 0x1f && secondbyte == 0x8b)
bigbiffce8f83c2015-12-12 18:30:21 -0500167 return COMPRESSED;
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600168 else if (firstbyte == 0x4f && secondbyte == 0x41)
bigbiffce8f83c2015-12-12 18:30:21 -0500169 return ENCRYPTED;
170 return UNCOMPRESSED; // default
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600171}
172
173int TWFunc::Try_Decrypting_File(string fn, string password) {
174#ifndef TW_EXCLUDE_ENCRYPTED_BACKUPS
175 OAES_CTX * ctx = NULL;
176 uint8_t _key_data[32] = "";
177 FILE *f;
178 uint8_t buffer[4096];
179 uint8_t *buffer_out = NULL;
180 uint8_t *ptr = NULL;
181 size_t read_len = 0, out_len = 0;
182 int firstbyte = 0, secondbyte = 0, key_len;
183 size_t _j = 0;
184 size_t _key_data_len = 0;
185
186 // mostly kanged from OpenAES oaes.c
187 for( _j = 0; _j < 32; _j++ )
188 _key_data[_j] = _j + 1;
189 _key_data_len = password.size();
190 if( 16 >= _key_data_len )
191 _key_data_len = 16;
192 else if( 24 >= _key_data_len )
193 _key_data_len = 24;
194 else
195 _key_data_len = 32;
196 memcpy(_key_data, password.c_str(), password.size());
197
198 ctx = oaes_alloc();
199 if (ctx == NULL) {
200 LOGERR("Failed to allocate OAES\n");
201 return -1;
202 }
203
204 oaes_key_import_data(ctx, _key_data, _key_data_len);
205
206 f = fopen(fn.c_str(), "rb");
207 if (f == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500208 LOGERR("Failed to open '%s' to try decrypt: %s\n", fn.c_str(), strerror(errno));
Matt Mower13a8f0b2015-09-26 15:40:03 -0500209 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600210 return -1;
211 }
212 read_len = fread(buffer, sizeof(uint8_t), 4096, f);
213 if (read_len <= 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500214 LOGERR("Read size during try decrypt failed: %s\n", strerror(errno));
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600215 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500216 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600217 return -1;
218 }
219 if (oaes_decrypt(ctx, buffer, read_len, NULL, &out_len) != OAES_RET_SUCCESS) {
220 LOGERR("Error: Failed to retrieve required buffer size for trying decryption.\n");
221 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500222 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600223 return -1;
224 }
225 buffer_out = (uint8_t *) calloc(out_len, sizeof(char));
226 if (buffer_out == NULL) {
227 LOGERR("Failed to allocate output buffer for try decrypt.\n");
228 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500229 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600230 return -1;
231 }
232 if (oaes_decrypt(ctx, buffer, read_len, buffer_out, &out_len) != OAES_RET_SUCCESS) {
233 LOGERR("Failed to decrypt file '%s'\n", fn.c_str());
234 fclose(f);
235 free(buffer_out);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500236 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600237 return 0;
238 }
239 fclose(f);
Matt Mower13a8f0b2015-09-26 15:40:03 -0500240 oaes_free(&ctx);
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600241 if (out_len < 2) {
Ethan Yonkerd0514ba2015-10-22 14:17:47 -0500242 LOGINFO("Successfully decrypted '%s' but read length too small.\n", fn.c_str());
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600243 free(buffer_out);
244 return 1; // Decrypted successfully
245 }
246 ptr = buffer_out;
247 firstbyte = *ptr & 0xff;
248 ptr++;
249 secondbyte = *ptr & 0xff;
250 if (firstbyte == 0x1f && secondbyte == 0x8b) {
251 LOGINFO("Successfully decrypted '%s' and file is compressed.\n", fn.c_str());
252 free(buffer_out);
253 return 3; // Compressed
254 }
255 if (out_len >= 262) {
256 ptr = buffer_out + 257;
257 if (strncmp((char*)ptr, "ustar", 5) == 0) {
258 LOGINFO("Successfully decrypted '%s' and file is tar format.\n", fn.c_str());
259 free(buffer_out);
260 return 2; // Tar
261 }
262 }
263 free(buffer_out);
264 LOGINFO("No errors decrypting '%s' but no known file format.\n", fn.c_str());
265 return 1; // Decrypted successfully
266#else
267 LOGERR("Encrypted backup support not included.\n");
268 return -1;
269#endif
270}
271
Ethan Yonker472f5062016-02-25 13:47:30 -0600272unsigned long TWFunc::Get_File_Size(const string& Path) {
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600273 struct stat st;
274
275 if (stat(Path.c_str(), &st) != 0)
276 return 0;
277 return st.st_size;
278}
279
Vojtech Bocek05f87d62014-03-11 22:08:23 +0100280std::string TWFunc::Remove_Trailing_Slashes(const std::string& path, bool leaveLast)
281{
282 std::string res;
283 size_t last_idx = 0, idx = 0;
284
285 while(last_idx != std::string::npos)
286 {
287 if(last_idx != 0)
288 res += '/';
289
290 idx = path.find_first_of('/', last_idx);
291 if(idx == std::string::npos) {
292 res += path.substr(last_idx, idx);
293 break;
294 }
295
296 res += path.substr(last_idx, idx-last_idx);
297 last_idx = path.find_first_not_of('/', idx);
298 }
299
300 if(leaveLast)
301 res += '/';
302 return res;
303}
304
Matt Mower2416a502016-04-12 19:54:46 -0500305void TWFunc::Strip_Quotes(char* &str) {
306 if (strlen(str) > 0 && str[0] == '\"')
307 str++;
308 if (strlen(str) > 0 && str[strlen(str)-1] == '\"')
309 str[strlen(str)-1] = 0;
310}
311
Ethan Yonker1b7a31b2014-07-03 15:09:22 -0500312vector<string> TWFunc::split_string(const string &in, char del, bool skip_empty) {
313 vector<string> res;
314
315 if (in.empty() || del == '\0')
316 return res;
317
318 string field;
319 istringstream f(in);
320 if (del == '\n') {
321 while(getline(f, field)) {
322 if (field.empty() && skip_empty)
323 continue;
324 res.push_back(field);
325 }
326 } else {
327 while(getline(f, field, del)) {
328 if (field.empty() && skip_empty)
329 continue;
330 res.push_back(field);
331 }
332 }
333 return res;
334}
335
Ethan Yonker472f5062016-02-25 13:47:30 -0600336timespec TWFunc::timespec_diff(timespec& start, timespec& end)
337{
338 timespec temp;
339 if ((end.tv_nsec-start.tv_nsec)<0) {
340 temp.tv_sec = end.tv_sec-start.tv_sec-1;
341 temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
342 } else {
343 temp.tv_sec = end.tv_sec-start.tv_sec;
344 temp.tv_nsec = end.tv_nsec-start.tv_nsec;
345 }
346 return temp;
347}
348
349int32_t TWFunc::timespec_diff_ms(timespec& start, timespec& end)
350{
351 return ((end.tv_sec * 1000) + end.tv_nsec/1000000) -
352 ((start.tv_sec * 1000) + start.tv_nsec/1000000);
353}
354
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600355#ifndef BUILD_TWRPTAR_MAIN
356
Dees_Troy38bd7602012-09-14 13:33:53 -0400357// Returns "/path" from a full /path/to/file.name
358string TWFunc::Get_Root_Path(string Path) {
359 string Local_Path = Path;
360
361 // Make sure that we have a leading slash
362 if (Local_Path.substr(0, 1) != "/")
363 Local_Path = "/" + Local_Path;
364
365 // Trim the path to get the root path only
366 size_t position = Local_Path.find("/", 2);
367 if (position != string::npos) {
368 Local_Path.resize(position);
369 }
370 return Local_Path;
371}
372
373void TWFunc::install_htc_dumlock(void) {
Dees_Troy38bd7602012-09-14 13:33:53 -0400374 int need_libs = 0;
375
376 if (!PartitionManager.Mount_By_Path("/system", true))
377 return;
378
379 if (!PartitionManager.Mount_By_Path("/data", true))
380 return;
381
Ethan Yonker74db1572015-10-28 12:44:49 -0500382 gui_msg("install_dumlock=Installing HTC Dumlock to system...");
Dees Troy3454ade2015-01-20 19:21:04 +0000383 copy_file(TWHTCD_PATH "htcdumlocksys", "/system/bin/htcdumlock", 0755);
Dees_Troy8170a922012-09-18 15:40:25 -0400384 if (!Path_Exists("/system/bin/flash_image")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500385 LOGINFO("Installing flash_image...\n");
Dees Troy3454ade2015-01-20 19:21:04 +0000386 copy_file(TWHTCD_PATH "flash_imagesys", "/system/bin/flash_image", 0755);
Dees_Troy38bd7602012-09-14 13:33:53 -0400387 need_libs = 1;
388 } else
Ethan Yonker74db1572015-10-28 12:44:49 -0500389 LOGINFO("flash_image is already installed, skipping...\n");
Dees_Troy8170a922012-09-18 15:40:25 -0400390 if (!Path_Exists("/system/bin/dump_image")) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500391 LOGINFO("Installing dump_image...\n");
Dees Troy3454ade2015-01-20 19:21:04 +0000392 copy_file(TWHTCD_PATH "dump_imagesys", "/system/bin/dump_image", 0755);
Dees_Troy38bd7602012-09-14 13:33:53 -0400393 need_libs = 1;
394 } else
Ethan Yonker74db1572015-10-28 12:44:49 -0500395 LOGINFO("dump_image is already installed, skipping...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400396 if (need_libs) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500397 LOGINFO("Installing libs needed for flash_image and dump_image...\n");
Dees Troy3454ade2015-01-20 19:21:04 +0000398 copy_file(TWHTCD_PATH "libbmlutils.so", "/system/lib/libbmlutils.so", 0644);
399 copy_file(TWHTCD_PATH "libflashutils.so", "/system/lib/libflashutils.so", 0644);
400 copy_file(TWHTCD_PATH "libmmcutils.so", "/system/lib/libmmcutils.so", 0644);
401 copy_file(TWHTCD_PATH "libmtdutils.so", "/system/lib/libmtdutils.so", 0644);
Dees_Troy38bd7602012-09-14 13:33:53 -0400402 }
Ethan Yonker74db1572015-10-28 12:44:49 -0500403 LOGINFO("Installing HTC Dumlock app...\n");
Dees_Troy38bd7602012-09-14 13:33:53 -0400404 mkdir("/data/app", 0777);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500405 unlink("/data/app/com.teamwin.htcdumlock*");
Dees Troy3454ade2015-01-20 19:21:04 +0000406 copy_file(TWHTCD_PATH "HTCDumlock.apk", "/data/app/com.teamwin.htcdumlock.apk", 0777);
Dees_Troy38bd7602012-09-14 13:33:53 -0400407 sync();
Ethan Yonker74db1572015-10-28 12:44:49 -0500408 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -0400409}
410
411void TWFunc::htc_dumlock_restore_original_boot(void) {
412 if (!PartitionManager.Mount_By_Path("/sdcard", true))
413 return;
414
Ethan Yonker74db1572015-10-28 12:44:49 -0500415 gui_msg("dumlock_restore=Restoring original boot...");
Vojtech Bocek05534202013-09-11 08:11:56 +0200416 Exec_Cmd("htcdumlock restore");
Ethan Yonker74db1572015-10-28 12:44:49 -0500417 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -0400418}
419
420void TWFunc::htc_dumlock_reflash_recovery_to_boot(void) {
421 if (!PartitionManager.Mount_By_Path("/sdcard", true))
422 return;
Ethan Yonker74db1572015-10-28 12:44:49 -0500423 gui_msg("dumlock_reflash=Reflashing recovery to boot...");
Vojtech Bocek05534202013-09-11 08:11:56 +0200424 Exec_Cmd("htcdumlock recovery noreboot");
Ethan Yonker74db1572015-10-28 12:44:49 -0500425 gui_msg("done=Done.");
Dees_Troy38bd7602012-09-14 13:33:53 -0400426}
Dees_Troy43d8b002012-09-17 16:00:01 -0400427
428int TWFunc::Recursive_Mkdir(string Path) {
thatf1408b32016-01-03 11:09:15 +0100429 std::vector<std::string> parts = Split_String(Path, "/", true);
430 std::string cur_path;
431 for (size_t i = 0; i < parts.size(); ++i) {
432 cur_path += "/" + parts[i];
433 if (!TWFunc::Path_Exists(cur_path)) {
434 if (mkdir(cur_path.c_str(), 0777)) {
Matt Mower3c366972015-12-25 19:28:31 -0600435 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 -0600436 return false;
437 } else {
thatf1408b32016-01-03 11:09:15 +0100438 tw_set_default_metadata(cur_path.c_str());
Ethan Yonker4b94cfd2014-12-11 10:00:45 -0600439 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400440 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400441 }
Dees_Troy43d8b002012-09-17 16:00:01 -0400442 return true;
443}
444
Dees_Troyb46a6842012-09-25 11:06:46 -0400445void TWFunc::GUI_Operation_Text(string Read_Value, string Default_Text) {
446 string Display_Text;
447
448 DataManager::GetValue(Read_Value, Display_Text);
449 if (Display_Text.empty())
450 Display_Text = Default_Text;
451
452 DataManager::SetValue("tw_operation", Display_Text);
453 DataManager::SetValue("tw_partition", "");
454}
455
456void TWFunc::GUI_Operation_Text(string Read_Value, string Partition_Name, string Default_Text) {
457 string Display_Text;
458
459 DataManager::GetValue(Read_Value, Display_Text);
460 if (Display_Text.empty())
461 Display_Text = Default_Text;
462
463 DataManager::SetValue("tw_operation", Display_Text);
464 DataManager::SetValue("tw_partition", Partition_Name);
Dees_Troy7c2dec82012-09-26 09:49:14 -0400465}
466
Dees_Troy2673cec2013-04-02 20:22:16 +0000467void TWFunc::Copy_Log(string Source, string Destination) {
Dees Troy9d7fdf52013-09-19 20:49:25 +0000468 PartitionManager.Mount_By_Path(Destination, false);
Dees_Troy2673cec2013-04-02 20:22:16 +0000469 FILE *destination_log = fopen(Destination.c_str(), "a");
470 if (destination_log == NULL) {
471 LOGERR("TWFunc::Copy_Log -- Can't open destination log file: '%s'\n", Destination.c_str());
Dees_Troy6ef66352013-02-21 08:26:57 -0600472 } else {
Dees_Troy2673cec2013-04-02 20:22:16 +0000473 FILE *source_log = fopen(Source.c_str(), "r");
474 if (source_log != NULL) {
475 fseek(source_log, Log_Offset, SEEK_SET);
476 char buffer[4096];
477 while (fgets(buffer, sizeof(buffer), source_log))
478 fputs(buffer, destination_log); // Buffered write of log file
479 Log_Offset = ftell(source_log);
480 fflush(source_log);
481 fclose(source_log);
Dees_Troy6ef66352013-02-21 08:26:57 -0600482 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000483 fflush(destination_log);
484 fclose(destination_log);
Dees_Troy6ef66352013-02-21 08:26:57 -0600485 }
Dees_Troya58bead2012-09-27 09:49:29 -0400486}
487
Dees_Troy2673cec2013-04-02 20:22:16 +0000488void TWFunc::Update_Log_File(void) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500489 // Copy logs to cache so the system can find out what happened.
Dees Troy9d7fdf52013-09-19 20:49:25 +0000490 if (PartitionManager.Mount_By_Path("/cache", false)) {
491 if (!TWFunc::Path_Exists("/cache/recovery/.")) {
492 LOGINFO("Recreating /cache/recovery folder.\n");
493 if (mkdir("/cache/recovery", S_IRWXU | S_IRWXG | S_IWGRP | S_IXGRP) != 0)
494 LOGINFO("Unable to create /cache/recovery folder.\n");
495 }
496 Copy_Log(TMP_LOG_FILE, "/cache/recovery/log");
497 copy_file("/cache/recovery/log", "/cache/recovery/last_log", 600);
498 chown("/cache/recovery/log", 1000, 1000);
499 chmod("/cache/recovery/log", 0600);
500 chmod("/cache/recovery/last_log", 0640);
Ethan Yonkerff2b7882016-12-10 09:04:41 -0600501 } else if (PartitionManager.Mount_By_Path("/data", false) && TWFunc::Path_Exists("/data/cache/recovery/.")) {
502 Copy_Log(TMP_LOG_FILE, "/data/cache/recovery/log");
503 copy_file("/data/cache/recovery/log", "/data/cache/recovery/last_log", 600);
504 chown("/data/cache/recovery/log", 1000, 1000);
505 chmod("/data/cache/recovery/log", 0600);
506 chmod("/data/cache/recovery/last_log", 0640);
Dees Troy9d7fdf52013-09-19 20:49:25 +0000507 } else {
Ethan Yonkerff2b7882016-12-10 09:04:41 -0600508 LOGINFO("Failed to mount /cache or find /data/cache for TWFunc::Update_Log_File\n");
Dees Troy9d7fdf52013-09-19 20:49:25 +0000509 }
Dees_Troya58bead2012-09-27 09:49:29 -0400510
Dees_Troy2673cec2013-04-02 20:22:16 +0000511 // Reset bootloader message
512 TWPartition* Part = PartitionManager.Find_Partition_By_Path("/misc");
513 if (Part != NULL) {
Ethan Yonkerb5236502016-11-19 22:24:59 -0600514 string err;
515 if (!clear_bootloader_message(&err)) {
516 if (err == "no misc device set") {
517 LOGINFO("%s\n", err.c_str());
518 } else {
519 LOGERR("%s\n", err.c_str());
520 }
521 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000522 }
Dees_Troya58bead2012-09-27 09:49:29 -0400523
Ethan Yonkerff2b7882016-12-10 09:04:41 -0600524 if (PartitionManager.Mount_By_Path("/cache", false)) {
Dees Troy9d7fdf52013-09-19 20:49:25 +0000525 if (unlink("/cache/recovery/command") && errno != ENOENT) {
526 LOGINFO("Can't unlink %s\n", "/cache/recovery/command");
527 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500528 }
Dees_Troya58bead2012-09-27 09:49:29 -0400529
Dees_Troy2673cec2013-04-02 20:22:16 +0000530 sync();
531}
532
533void TWFunc::Update_Intent_File(string Intent) {
534 if (PartitionManager.Mount_By_Path("/cache", false) && !Intent.empty()) {
535 TWFunc::write_file("/cache/recovery/intent", Intent);
536 }
Dees_Troya58bead2012-09-27 09:49:29 -0400537}
538
539// reboot: Reboot the system. Return -1 on error, no return on success
540int TWFunc::tw_reboot(RebootCommand command)
541{
Ethan Yonkerfe916112016-03-14 14:54:37 -0500542 DataManager::Flush();
543 Update_Log_File();
Dees_Troya58bead2012-09-27 09:49:29 -0400544 // Always force a sync before we reboot
Dees_Troy6ef66352013-02-21 08:26:57 -0600545 sync();
Dees_Troya58bead2012-09-27 09:49:29 -0400546
Dees_Troy2673cec2013-04-02 20:22:16 +0000547 switch (command) {
548 case rb_current:
549 case rb_system:
Dees_Troy2673cec2013-04-02 20:22:16 +0000550 Update_Intent_File("s");
551 sync();
552 check_and_run_script("/sbin/rebootsystem.sh", "reboot system");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500553#ifdef ANDROID_RB_PROPERTY
554 return property_set(ANDROID_RB_PROPERTY, "reboot,");
555#elif defined(ANDROID_RB_RESTART)
556 return android_reboot(ANDROID_RB_RESTART, 0, 0);
557#else
Dees_Troy2673cec2013-04-02 20:22:16 +0000558 return reboot(RB_AUTOBOOT);
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500559#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000560 case rb_recovery:
561 check_and_run_script("/sbin/rebootrecovery.sh", "reboot recovery");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600562#ifdef ANDROID_RB_PROPERTY
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500563 return property_set(ANDROID_RB_PROPERTY, "reboot,recovery");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600564#else
565 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "recovery");
566#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000567 case rb_bootloader:
568 check_and_run_script("/sbin/rebootbootloader.sh", "reboot bootloader");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600569#ifdef ANDROID_RB_PROPERTY
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500570 return property_set(ANDROID_RB_PROPERTY, "reboot,bootloader");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600571#else
572 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "bootloader");
573#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000574 case rb_poweroff:
575 check_and_run_script("/sbin/poweroff.sh", "power off");
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500576#ifdef ANDROID_RB_PROPERTY
577 return property_set(ANDROID_RB_PROPERTY, "shutdown,");
578#elif defined(ANDROID_RB_POWEROFF)
579 return android_reboot(ANDROID_RB_POWEROFF, 0, 0);
580#else
Dees_Troy2673cec2013-04-02 20:22:16 +0000581 return reboot(RB_POWER_OFF);
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500582#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000583 case rb_download:
584 check_and_run_script("/sbin/rebootdownload.sh", "reboot download");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600585#ifdef ANDROID_RB_PROPERTY
Ethan Yonkerbc2bc6b2015-03-24 21:37:52 -0500586 return property_set(ANDROID_RB_PROPERTY, "reboot,download");
Ethan Yonker75bf0412014-11-21 13:54:27 -0600587#else
588 return __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, (void*) "download");
589#endif
Dees_Troy2673cec2013-04-02 20:22:16 +0000590 default:
591 return -1;
Dees_Troy6ef66352013-02-21 08:26:57 -0600592 }
593 return -1;
Dees_Troya58bead2012-09-27 09:49:29 -0400594}
595
596void TWFunc::check_and_run_script(const char* script_file, const char* display_name)
597{
598 // Check for and run startup script if script exists
599 struct stat st;
600 if (stat(script_file, &st) == 0) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500601 gui_msg(Msg("run_script=Running {1} script...")(display_name));
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500602 chmod(script_file, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
Vojtech Bocek05534202013-09-11 08:11:56 +0200603 TWFunc::Exec_Cmd(script_file);
Ethan Yonker74db1572015-10-28 12:44:49 -0500604 gui_msg("done=Done.");
Dees_Troya58bead2012-09-27 09:49:29 -0400605 }
Dees_Troy3477d712012-09-27 15:44:01 -0400606}
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500607
608int TWFunc::removeDir(const string path, bool skipParent) {
Dees_Troyce675462013-01-09 19:48:21 +0000609 DIR *d = opendir(path.c_str());
610 int r = 0;
611 string new_path;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500612
Dees_Troyce675462013-01-09 19:48:21 +0000613 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500614 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(path)(strerror(errno)));
Dees_Troyce675462013-01-09 19:48:21 +0000615 return -1;
616 }
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500617
Dees_Troyce675462013-01-09 19:48:21 +0000618 if (d) {
619 struct dirent *p;
620 while (!r && (p = readdir(d))) {
Dees_Troyce675462013-01-09 19:48:21 +0000621 if (!strcmp(p->d_name, ".") || !strcmp(p->d_name, ".."))
622 continue;
623 new_path = path + "/";
624 new_path.append(p->d_name);
625 if (p->d_type == DT_DIR) {
626 r = removeDir(new_path, true);
627 if (!r) {
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500628 if (p->d_type == DT_DIR)
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500629 r = rmdir(new_path.c_str());
630 else
Dees_Troy2673cec2013-04-02 20:22:16 +0000631 LOGINFO("Unable to removeDir '%s': %s\n", new_path.c_str(), strerror(errno));
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500632 }
bigbiff bigbiff98f1f902013-01-19 18:46:13 -0500633 } 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 +0000634 r = unlink(new_path.c_str());
Dees_Troye34c1332013-02-06 19:13:00 +0000635 if (r != 0) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000636 LOGINFO("Unable to unlink '%s: %s'\n", new_path.c_str(), strerror(errno));
Dees_Troye34c1332013-02-06 19:13:00 +0000637 }
Dees_Troyce675462013-01-09 19:48:21 +0000638 }
639 }
640 closedir(d);
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500641
Matt Mowerfb1c4ff2014-04-16 13:43:36 -0500642 if (!r) {
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500643 if (skipParent)
644 return 0;
645 else
646 r = rmdir(path.c_str());
647 }
Dees_Troyce675462013-01-09 19:48:21 +0000648 }
649 return r;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500650}
651
652int TWFunc::copy_file(string src, string dst, int mode) {
Dees_Troy2673cec2013-04-02 20:22:16 +0000653 LOGINFO("Copying file %s to %s\n", src.c_str(), dst.c_str());
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500654 ifstream srcfile(src.c_str(), ios::binary);
655 ofstream dstfile(dst.c_str(), ios::binary);
656 dstfile << srcfile.rdbuf();
657 srcfile.close();
658 dstfile.close();
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500659 if (chmod(dst.c_str(), mode) != 0)
660 return -1;
bigbiff bigbiff9c754052013-01-09 09:09:08 -0500661 return 0;
662}
Dees_Troy3ee47bc2013-01-25 21:47:37 +0000663
664unsigned int TWFunc::Get_D_Type_From_Stat(string Path) {
665 struct stat st;
666
667 stat(Path.c_str(), &st);
668 if (st.st_mode & S_IFDIR)
669 return DT_DIR;
670 else if (st.st_mode & S_IFBLK)
671 return DT_BLK;
672 else if (st.st_mode & S_IFCHR)
673 return DT_CHR;
674 else if (st.st_mode & S_IFIFO)
675 return DT_FIFO;
676 else if (st.st_mode & S_IFLNK)
677 return DT_LNK;
678 else if (st.st_mode & S_IFREG)
679 return DT_REG;
680 else if (st.st_mode & S_IFSOCK)
681 return DT_SOCK;
682 return DT_UNKNOWN;
Dees_Troye34c1332013-02-06 19:13:00 +0000683}
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500684
685int TWFunc::read_file(string fn, string& results) {
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200686 ifstream file;
687 file.open(fn.c_str(), ios::in);
688
689 if (file.is_open()) {
690 file >> results;
691 file.close();
692 return 0;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500693 }
Vojtech Bocekfafb0c52013-07-25 22:53:02 +0200694
695 LOGINFO("Cannot find file %s\n", fn.c_str());
696 return -1;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500697}
698
699int TWFunc::read_file(string fn, vector<string>& results) {
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500700 ifstream file;
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500701 string line;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500702 file.open(fn.c_str(), ios::in);
703 if (file.is_open()) {
bigbiff bigbiffcdcfee42013-02-27 21:11:26 -0500704 while (getline(file, line))
705 results.push_back(line);
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500706 file.close();
707 return 0;
708 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000709 LOGINFO("Cannot find file %s\n", fn.c_str());
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500710 return -1;
711}
712
xNUTxe85f02d2014-07-18 01:30:58 +0200713int TWFunc::read_file(string fn, uint64_t& results) {
714 ifstream file;
715 file.open(fn.c_str(), ios::in);
716
717 if (file.is_open()) {
718 file >> results;
719 file.close();
720 return 0;
721 }
722
723 LOGINFO("Cannot find file %s\n", fn.c_str());
724 return -1;
725}
726
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500727int TWFunc::write_file(string fn, string& line) {
728 FILE *file;
729 file = fopen(fn.c_str(), "w");
730 if (file != NULL) {
731 fwrite(line.c_str(), line.size(), 1, file);
732 fclose(file);
733 return 0;
734 }
Dees_Troy2673cec2013-04-02 20:22:16 +0000735 LOGINFO("Cannot find file %s\n", fn.c_str());
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500736 return -1;
737}
738
Dees_Troy6ef66352013-02-21 08:26:57 -0600739bool TWFunc::Install_SuperSU(void) {
740 if (!PartitionManager.Mount_By_Path("/system", true))
741 return false;
742
Ethan Yonkere3e88292014-12-10 16:17:55 -0600743 check_and_run_script("/supersu/install-supersu.sh", "SuperSU");
Dees_Troy6ef66352013-02-21 08:26:57 -0600744 return true;
bigbiff bigbiff8a68c312013-02-10 14:28:30 -0500745}
Dees_Troy83bd4832013-05-04 12:39:56 +0000746
Dees_Troy83bd4832013-05-04 12:39:56 +0000747bool TWFunc::Try_Decrypting_Backup(string Restore_Path, string Password) {
748 DIR* d;
749
750 string Filename;
751 Restore_Path += "/";
752 d = opendir(Restore_Path.c_str());
753 if (d == NULL) {
Ethan Yonker74db1572015-10-28 12:44:49 -0500754 gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Path)(strerror(errno)));
Dees_Troy83bd4832013-05-04 12:39:56 +0000755 return false;
756 }
757
758 struct dirent* de;
759 while ((de = readdir(d)) != NULL) {
760 Filename = Restore_Path;
761 Filename += de->d_name;
bigbiffce8f83c2015-12-12 18:30:21 -0500762 if (TWFunc::Get_File_Type(Filename) == ENCRYPTED) {
Dees_Troy83bd4832013-05-04 12:39:56 +0000763 if (TWFunc::Try_Decrypting_File(Filename, Password) < 2) {
764 DataManager::SetValue("tw_restore_password", ""); // Clear the bad password
765 DataManager::SetValue("tw_restore_display", ""); // Also clear the display mask
766 closedir(d);
767 return false;
768 }
769 }
770 }
771 closedir(d);
772 return true;
773}
774
Dees Troyb21cc642013-09-10 17:36:41 +0000775string TWFunc::Get_Current_Date() {
776 string Current_Date;
777 time_t seconds = time(0);
778 struct tm *t = localtime(&seconds);
779 char timestamp[255];
780 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);
781 Current_Date = timestamp;
782 return Current_Date;
783}
784
Ethan Yonkerb5557892014-02-07 21:43:20 -0600785string TWFunc::System_Property_Get(string Prop_Name) {
Dees Troyb21cc642013-09-10 17:36:41 +0000786 bool mount_state = PartitionManager.Is_Mounted_By_Path("/system");
787 std::vector<string> buildprop;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600788 string propvalue;
789 if (!PartitionManager.Mount_By_Path("/system", true))
790 return propvalue;
Ethan Yonkerb4bff5e2016-12-16 07:47:58 -0600791 string prop_file = "/system/build.prop";
792 if (!TWFunc::Path_Exists(prop_file))
793 prop_file = "/system/system/build.prop"; // for devices with system as a root file system (e.g. Pixel)
794 if (TWFunc::read_file(prop_file, buildprop) != 0) {
Ethan Yonkerb5557892014-02-07 21:43:20 -0600795 LOGINFO("Unable to open /system/build.prop for getting '%s'.\n", Prop_Name.c_str());
Vojtech Boceka2e70162013-09-17 17:05:10 +0200796 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
Dees Troyb21cc642013-09-10 17:36:41 +0000797 if (!mount_state)
798 PartitionManager.UnMount_By_Path("/system", false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600799 return propvalue;
Dees Troyb21cc642013-09-10 17:36:41 +0000800 }
801 int line_count = buildprop.size();
802 int index;
803 size_t start_pos = 0, end_pos;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600804 string propname;
Dees Troyb21cc642013-09-10 17:36:41 +0000805 for (index = 0; index < line_count; index++) {
806 end_pos = buildprop.at(index).find("=", start_pos);
807 propname = buildprop.at(index).substr(start_pos, end_pos);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600808 if (propname == Prop_Name) {
Dees Troyb21cc642013-09-10 17:36:41 +0000809 propvalue = buildprop.at(index).substr(end_pos + 1, buildprop.at(index).size());
Ethan Yonkerb5557892014-02-07 21:43:20 -0600810 if (!mount_state)
811 PartitionManager.UnMount_By_Path("/system", false);
812 return propvalue;
Dees Troyb21cc642013-09-10 17:36:41 +0000813 }
814 }
Dees Troyb21cc642013-09-10 17:36:41 +0000815 if (!mount_state)
816 PartitionManager.UnMount_By_Path("/system", false);
Ethan Yonkerb5557892014-02-07 21:43:20 -0600817 return propvalue;
818}
819
820void TWFunc::Auto_Generate_Backup_Name() {
821 string propvalue = System_Property_Get("ro.build.display.id");
822 if (propvalue.empty()) {
823 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
824 return;
825 }
826 string Backup_Name = Get_Current_Date();
bigbiff74a6d0d2015-02-14 20:49:44 -0500827 Backup_Name += "_" + propvalue;
Ethan Yonkerb5557892014-02-07 21:43:20 -0600828 if (Backup_Name.size() > MAX_BACKUP_NAME_LEN)
829 Backup_Name.resize(MAX_BACKUP_NAME_LEN);
830 // Trailing spaces cause problems on some file systems, so remove them
831 string space_check, space = " ";
832 space_check = Backup_Name.substr(Backup_Name.size() - 1, 1);
833 while (space_check == space) {
834 Backup_Name.resize(Backup_Name.size() - 1);
835 space_check = Backup_Name.substr(Backup_Name.size() - 1, 1);
836 }
bigbiff74a6d0d2015-02-14 20:49:44 -0500837 replace(Backup_Name.begin(), Backup_Name.end(), ' ', '_');
Ethan Yonkerb5557892014-02-07 21:43:20 -0600838 DataManager::SetValue(TW_BACKUP_NAME, Backup_Name);
Ethan Yonker92d48e02014-02-26 12:05:55 -0600839 if (PartitionManager.Check_Backup_Name(false) != 0) {
840 LOGINFO("Auto generated backup name '%s' contains invalid characters, using date instead.\n", Backup_Name.c_str());
841 DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date());
842 }
Vojtech Bocek05534202013-09-11 08:11:56 +0200843}
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100844
845void TWFunc::Fixup_Time_On_Boot()
846{
847#ifdef QCOM_RTC_FIX
xNUTxe85f02d2014-07-18 01:30:58 +0200848
849 LOGINFO("TWFunc::Fixup_Time: Pre-fix date and time: %s\n", TWFunc::Get_Current_Date().c_str());
850
851 struct timeval tv;
852 uint64_t offset = 0;
853 std::string sepoch = "/sys/class/rtc/rtc0/since_epoch";
854
855 if (TWFunc::read_file(sepoch, offset) == 0) {
856
857 LOGINFO("TWFunc::Fixup_Time: Setting time offset from file %s\n", sepoch.c_str());
858
859 tv.tv_sec = offset;
860 tv.tv_usec = 0;
861 settimeofday(&tv, NULL);
862
863 gettimeofday(&tv, NULL);
864
865 if (tv.tv_sec > 1405209403) { // Anything older then 12 Jul 2014 23:56:43 GMT will do nicely thank you ;)
866
867 LOGINFO("TWFunc::Fixup_Time: Date and time corrected: %s\n", TWFunc::Get_Current_Date().c_str());
868 return;
869
870 }
871
872 } else {
873
874 LOGINFO("TWFunc::Fixup_Time: opening %s failed\n", sepoch.c_str());
875
876 }
877
Ethan Yonker9132d912015-02-02 10:32:49 -0600878 LOGINFO("TWFunc::Fixup_Time: will attempt to use the ats files now.\n");
xNUTxe85f02d2014-07-18 01:30:58 +0200879
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100880 // Devices with Qualcomm Snapdragon 800 do some shenanigans with RTC.
881 // They never set it, it just ticks forward from 1970-01-01 00:00,
882 // and then they have files /data/system/time/ats_* with 64bit offset
883 // in miliseconds which, when added to the RTC, gives the correct time.
884 // So, the time is: (offset_from_ats + value_from_RTC)
885 // There are multiple ats files, they are for different systems? Bases?
886 // Like, ats_1 is for modem and ats_2 is for TOD (time of day?).
887 // Look at file time_genoff.h in CodeAurora, qcom-opensource/time-services
888
889 static const char *paths[] = { "/data/system/time/", "/data/time/" };
890
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100891 FILE *f;
xNUTxe85f02d2014-07-18 01:30:58 +0200892 DIR *d;
893 offset = 0;
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100894 struct dirent *dt;
895 std::string ats_path;
896
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100897 if(!PartitionManager.Mount_By_Path("/data", false))
898 return;
899
900 // Prefer ats_2, it seems to be the one we want according to logcat on hammerhead
901 // - it is the one for ATS_TOD (time of day?).
902 // However, I never saw a device where the offset differs between ats files.
903 for(size_t i = 0; i < (sizeof(paths)/sizeof(paths[0])); ++i)
904 {
905 DIR *d = opendir(paths[i]);
906 if(!d)
907 continue;
908
909 while((dt = readdir(d)))
910 {
911 if(dt->d_type != DT_REG || strncmp(dt->d_name, "ats_", 4) != 0)
912 continue;
913
914 if(ats_path.empty() || strcmp(dt->d_name, "ats_2") == 0)
915 ats_path = std::string(paths[i]).append(dt->d_name);
916 }
917
918 closedir(d);
919 }
920
921 if(ats_path.empty())
922 {
xNUTxe85f02d2014-07-18 01:30:58 +0200923 LOGINFO("TWFunc::Fixup_Time: no ats files found, leaving untouched!\n");
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100924 return;
925 }
926
927 f = fopen(ats_path.c_str(), "r");
928 if(!f)
929 {
Dees Troy3e254b92014-03-06 20:24:54 +0000930 LOGINFO("TWFunc::Fixup_Time: failed to open file %s\n", ats_path.c_str());
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100931 return;
932 }
933
934 if(fread(&offset, sizeof(offset), 1, f) != 1)
935 {
Dees Troy3e254b92014-03-06 20:24:54 +0000936 LOGINFO("TWFunc::Fixup_Time: failed load uint64 from file %s\n", ats_path.c_str());
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100937 fclose(f);
938 return;
939 }
940 fclose(f);
941
942 LOGINFO("TWFunc::Fixup_Time: Setting time offset from file %s, offset %llu\n", ats_path.c_str(), offset);
943
944 gettimeofday(&tv, NULL);
945
946 tv.tv_sec += offset/1000;
947 tv.tv_usec += (offset%1000)*1000;
948
949 while(tv.tv_usec >= 1000000)
950 {
951 ++tv.tv_sec;
952 tv.tv_usec -= 1000000;
953 }
954
955 settimeofday(&tv, NULL);
xNUTxe85f02d2014-07-18 01:30:58 +0200956
957 LOGINFO("TWFunc::Fixup_Time: Date and time corrected: %s\n", TWFunc::Get_Current_Date().c_str());
958
Vojtech Bocekd0e38bc2014-02-03 23:36:57 +0100959#endif
960}
Ethan Yonkeraf2897c2014-02-10 13:07:14 -0600961
Vojtech Bocek0b7fe502014-03-13 17:36:52 +0100962std::vector<std::string> TWFunc::Split_String(const std::string& str, const std::string& delimiter, bool removeEmpty)
963{
964 std::vector<std::string> res;
965 size_t idx = 0, idx_last = 0;
966
967 while(idx < str.size())
968 {
969 idx = str.find_first_of(delimiter, idx_last);
970 if(idx == std::string::npos)
971 idx = str.size();
972
973 if(idx-idx_last != 0 || !removeEmpty)
974 res.push_back(str.substr(idx_last, idx-idx_last));
975
976 idx_last = idx + delimiter.size();
977 }
978
979 return res;
980}
981
Vojtech Bocek03fd6c52014-03-13 18:46:34 +0100982bool TWFunc::Create_Dir_Recursive(const std::string& path, mode_t mode, uid_t uid, gid_t gid)
983{
984 std::vector<std::string> parts = Split_String(path, "/");
985 std::string cur_path;
986 struct stat info;
987 for(size_t i = 0; i < parts.size(); ++i)
988 {
989 cur_path += "/" + parts[i];
990 if(stat(cur_path.c_str(), &info) < 0 || !S_ISDIR(info.st_mode))
991 {
992 if(mkdir(cur_path.c_str(), mode) < 0)
993 return false;
994 chown(cur_path.c_str(), uid, gid);
995 }
996 }
997 return true;
998}
999
xNUTxe85f02d2014-07-18 01:30:58 +02001000int TWFunc::Set_Brightness(std::string brightness_value)
1001{
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001002 int result = -1;
1003 std::string secondary_brightness_file;
xNUTxe85f02d2014-07-18 01:30:58 +02001004
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001005 if (DataManager::GetIntValue("tw_has_brightnesss_file")) {
xNUTxe85f02d2014-07-18 01:30:58 +02001006 LOGINFO("TWFunc::Set_Brightness: Setting brightness control to %s\n", brightness_value.c_str());
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001007 result = TWFunc::write_file(DataManager::GetStrValue("tw_brightness_file"), brightness_value);
1008 DataManager::GetValue("tw_secondary_brightness_file", secondary_brightness_file);
1009 if (!secondary_brightness_file.empty()) {
1010 LOGINFO("TWFunc::Set_Brightness: Setting secondary brightness control to %s\n", brightness_value.c_str());
xNUTxe85f02d2014-07-18 01:30:58 +02001011 TWFunc::write_file(secondary_brightness_file, brightness_value);
1012 }
xNUTxe85f02d2014-07-18 01:30:58 +02001013 }
Tatsuyuki Ishi548a1752015-12-28 10:08:58 +09001014 return result;
xNUTxe85f02d2014-07-18 01:30:58 +02001015}
1016
bigbiff bigbiffc7eee6f2014-09-02 18:59:01 -04001017bool TWFunc::Toggle_MTP(bool enable) {
1018#ifdef TW_HAS_MTP
1019 static int was_enabled = false;
1020
1021 if (enable && was_enabled) {
1022 if (!PartitionManager.Enable_MTP())
1023 PartitionManager.Disable_MTP();
1024 } else {
1025 was_enabled = DataManager::GetIntValue("tw_mtp_enabled");
1026 PartitionManager.Disable_MTP();
1027 usleep(500);
1028 }
1029 return was_enabled;
1030#else
1031 return false;
1032#endif
1033}
1034
Tom Hite5a926722014-09-15 01:31:03 +00001035void TWFunc::SetPerformanceMode(bool mode) {
1036 if (mode) {
1037 property_set("recovery.perf.mode", "1");
1038 } else {
1039 property_set("recovery.perf.mode", "0");
1040 }
1041 // Some time for events to catch up to init handlers
1042 usleep(500000);
1043}
1044
Jenkins1710bf22014-10-02 20:22:21 -04001045std::string TWFunc::to_string(unsigned long value) {
1046 std::ostringstream os;
1047 os << value;
1048 return os.str();
1049}
1050
Ethan Yonker9132d912015-02-02 10:32:49 -06001051void TWFunc::Disable_Stock_Recovery_Replace(void) {
1052 if (PartitionManager.Mount_By_Path("/system", false)) {
1053 // Disable flashing of stock recovery
1054 if (TWFunc::Path_Exists("/system/recovery-from-boot.p")) {
1055 rename("/system/recovery-from-boot.p", "/system/recovery-from-boot.bak");
Ethan Yonker74db1572015-10-28 12:44:49 -05001056 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 -06001057 sync();
1058 }
1059 PartitionManager.UnMount_By_Path("/system", false);
1060 }
1061}
1062
Ethan Yonker483e9f42016-01-11 22:21:18 -06001063unsigned long long TWFunc::IOCTL_Get_Block_Size(const char* block_device) {
1064 unsigned long block_device_size;
1065 int ret = 0;
1066
1067 int fd = open(block_device, O_RDONLY);
1068 if (fd < 0) {
1069 LOGINFO("Find_Partition_Size: Failed to open '%s', (%s)\n", block_device, strerror(errno));
1070 } else {
1071 ret = ioctl(fd, BLKGETSIZE, &block_device_size);
1072 close(fd);
1073 if (ret) {
1074 LOGINFO("Find_Partition_Size: ioctl error: (%s)\n", strerror(errno));
1075 } else {
1076 return (unsigned long long)(block_device_size) * 512LLU;
1077 }
1078 }
1079 return 0;
1080}
1081
bigbiff bigbiffbad332a2016-07-29 21:18:13 -04001082void TWFunc::copy_kernel_log(string curr_storage) {
1083 std::string dmesgDst = curr_storage + "/dmesg.log";
1084 std::string dmesgCmd = "/sbin/dmesg";
1085
1086 std::string result;
1087 Exec_Cmd(dmesgCmd, result);
1088 write_file(dmesgDst, result);
1089 gui_msg(Msg("copy_kernel_log=Copied kernel log to {1}")(dmesgDst));
1090 tw_set_default_metadata(dmesgDst.c_str());
1091}
Ethan Yonkeraf2897c2014-02-10 13:07:14 -06001092#endif // ndef BUILD_TWRPTAR_MAIN