From 19fb79c722622ac4a068e258501ab4b161420cda Mon Sep 17 00:00:00 2001 From: bigbiff bigbiff Date: Mon, 5 Sep 2016 21:04:51 -0400 Subject: ADB Backup: add ability for TWRP GUI to restore Restore adb backup files that TWRP made to your PC. Put files in your backup directory to see them. e.g. /sdcard/TWRP/BACKUPS/ Change-Id: I2c57970d77b64c39a302159041456e761c185259 --- Android.mk | 3 +- adbbu/Android.mk | 47 +++--- adbbu/adbbumain.cpp | 89 +++++++++++ adbbu/libtwadbbu.cpp | 112 +++++++++++++- adbbu/libtwadbbu.hpp | 9 +- adbbu/twadbstream.h | 26 ++-- adbbu/twrpback.cpp | 158 ++++++++----------- adbbu/twrpback.hpp | 24 ++- gui/action.cpp | 46 ++++-- gui/fileselector.cpp | 10 +- gui/gui.cpp | 8 - gui/theme/common/landscape.xml | 3 +- gui/theme/common/portrait.xml | 3 +- gui/theme/common/watch.xml | 3 +- openrecoveryscript.cpp | 263 +------------------------------- openrecoveryscript.hpp | 4 +- partition.cpp | 2 +- partitionmanager.cpp | 191 +++++++++++++---------- partitions.hpp | 2 +- twinstall.cpp | 2 +- twrp-functions.cpp | 24 +++ twrp-functions.hpp | 2 + twrp.cpp | 6 + twrpAdbBuFifo.cpp | 336 +++++++++++++++++++++++++++++++++++++++++ twrpAdbBuFifo.hpp | 40 +++++ 25 files changed, 890 insertions(+), 523 deletions(-) create mode 100644 adbbu/adbbumain.cpp create mode 100644 twrpAdbBuFifo.cpp create mode 100644 twrpAdbBuFifo.hpp diff --git a/Android.mk b/Android.mk index 04b8653e1..11bf006b7 100644 --- a/Android.mk +++ b/Android.mk @@ -61,7 +61,8 @@ LOCAL_SRC_FILES := \ twrp-functions.cpp \ twrpDigestDriver.cpp \ openrecoveryscript.cpp \ - tarWrite.c + tarWrite.c \ + twrpAdbBuFifo.cpp ifneq ($(TARGET_RECOVERY_REBOOT_SRC),) LOCAL_SRC_FILES += $(TARGET_RECOVERY_REBOOT_SRC) diff --git a/adbbu/Android.mk b/adbbu/Android.mk index 33d3ad7d3..efb5f9ae5 100644 --- a/adbbu/Android.mk +++ b/adbbu/Android.mk @@ -1,10 +1,35 @@ LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := libtwadbbu +LOCAL_MODULE_TAGS := optional +LOCAL_CFLAGS = -fno-strict-aliasing -D_LARGFILE_SOURCE +LOCAL_C_INCLUDES += bionic external/zlib +ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 23; echo $$?),0) + LOCAL_C_INCLUDES += external/stlport/stlport +endif + +LOCAL_SRC_FILES = \ + libtwadbbu.cpp \ + twrpback.cpp + +LOCAL_SHARED_LIBRARIES += libz libc libstdc++ libtwrpdigest + +ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 23; echo $$?),0) + LOCAL_SHARED_LIBRARIES += libstlport +else + LOCAL_SHARED_LIBRARIES += libc++ +endif + +include $(BUILD_SHARED_LIBRARY) + include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ - twrpback.cpp + adbbumain.cpp + +LOCAL_SHARED_LIBRARIES += libstdc++ libz libtwadbbu -LOCAL_SHARED_LIBRARIES += libstdc++ libz libtwrpdigest ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 23; echo $$?),0) LOCAL_C_INCLUDES += external/stlport/stlport LOCAL_SHARED_LIBRARIES += libstlport @@ -21,21 +46,3 @@ LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin include $(BUILD_EXECUTABLE) -include $(CLEAR_VARS) -LOCAL_MODULE := libtwadbbu -LOCAL_MODULE_TAGS := optional -LOCAL_CFLAGS = -D_FILE_OFFSET_BITS=64 -fno-strict-aliasing -LOCAL_C_INCLUDES += bionic external/zlib -ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 23; echo $$?),0) - LOCAL_C_INCLUDES += external/stlport/stlport - LOCAL_SHARED_LIBRARIES += libstlport -else - LOCAL_SHARED_LIBRARIES += libc++ -endif - -LOCAL_SRC_FILES = \ - libtwadbbu.cpp - -LOCAL_SHARED_LIBRARIES += libz libc libstdc++ - -include $(BUILD_SHARED_LIBRARY) diff --git a/adbbu/adbbumain.cpp b/adbbu/adbbumain.cpp new file mode 100644 index 000000000..050c9bc4a --- /dev/null +++ b/adbbu/adbbumain.cpp @@ -0,0 +1,89 @@ +/* + Copyright 2013 to 2017 TeamWin + TWRP is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + TWRP is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with TWRP. If not, see . +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "twrpback.hpp" +#include "twadbstream.h" + + +int main(int argc, char **argv) { + int index; + int ret = 0, pos = 0; + int maxpos = sizeof(TWRPARG + 2); + std::string command; + twrpback tw; + + tw.adblogwrite("Starting adb backup and restore\n"); + command = argv[1]; + for (index = 2; index < argc; index++) { + command = command + " " + argv[index]; + } + + pos = command.find(TWRP_BACKUP_ARG); + if (pos < 0 || pos > (maxpos + sizeof(TWRP_BACKUP_ARG) + 1)) { + pos = command.find(TWRP_RESTORE_ARG); + } + if (pos < 0 || pos > maxpos + sizeof(TWRP_STREAM_ARG + 1)) { + pos = command.find(TWRP_STREAM_ARG); + } + + tw.adblogwrite("command: " + command + "\n"); + command.erase(0, pos); + command.erase(std::remove(command.begin(), command.end(), '\''), command.end()); + + if (command.substr(0, sizeof(TWRP_BACKUP_ARG) - 1) == TWRP_BACKUP_ARG) { + tw.adblogwrite("Starting adb backup\n"); + if (isdigit(*argv[1])) + tw.adbd_fd = atoi(argv[1]); + else + tw.adbd_fd = 1; + ret = tw.backup(command); + } + else if (command.substr(0, sizeof(TWRP_RESTORE_ARG) - 1) == TWRP_RESTORE_ARG) { + tw.adblogwrite("Starting adb restore\n"); + if (isdigit(*argv[1])) + tw.adbd_fd = atoi(argv[1]); + else + tw.adbd_fd = 0; + ret = tw.restore(); + } + else if (command.substr(0, sizeof(TWRP_STREAM_ARG) - 1) == TWRP_STREAM_ARG) { + tw.setStreamFileName(argv[3]); + tw.threadStream(); + } + if (ret == 0) + tw.adblogwrite("Adb backup/restore completed\n"); + else + tw.adblogwrite("Adb backup/restore failed\n"); + + if (unlink(TW_ADB_BU_CONTROL) < 0) { + std::stringstream str; + str << strerror(errno); + tw.adblogwrite("Unable to remove TW_ADB_BU_CONTROL: " + str.str()); + } + unlink(TW_ADB_TWRP_CONTROL); + return ret; +} diff --git a/adbbu/libtwadbbu.cpp b/adbbu/libtwadbbu.cpp index cdc2170ba..a13ecb2c3 100644 --- a/adbbu/libtwadbbu.cpp +++ b/adbbu/libtwadbbu.cpp @@ -1,5 +1,5 @@ /* - Copyright 2013 to 2016 TeamWin + Copyright 2013 to 2017 TeamWin TWRP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or @@ -27,12 +27,107 @@ #include #include #include +#include #include #include #include "twadbstream.h" #include "libtwadbbu.hpp" +bool twadbbu::Check_ADB_Backup_File(std::string fname) { + struct AdbBackupStreamHeader adbbuhdr; + uint32_t crc, adbbuhdrcrc; + unsigned char buf[MAX_ADB_READ]; + int bytes; + + int fd = open(fname.c_str(), O_RDONLY); + if (fd < 0) { + printf("Unable to open %s for reading: %s.\n", fname.c_str(), strerror(errno)); + close(fd); + return false; + } + bytes = read(fd, &buf, sizeof(buf)); + close(fd); + + if (memcpy(&adbbuhdr, buf, sizeof(adbbuhdr)) < 0) { + printf("Unable to memcpy: %s.\n", fname.c_str(), strerror(errno)); + return false; + } + adbbuhdrcrc = adbbuhdr.crc; + memset(&adbbuhdr.crc, 0, sizeof(adbbuhdr.crc)); + crc = crc32(0L, Z_NULL, 0); + crc = crc32(crc, (const unsigned char*) &adbbuhdr, sizeof(adbbuhdr)); + + return (crc == adbbuhdrcrc); +} + +std::vector twadbbu::Get_ADB_Backup_Files(std::string fname) { + unsigned char buf[MAX_ADB_READ]; + struct AdbBackupControlType structcmd; + std::vector adb_partitions; + + int fd = open(fname.c_str(), O_RDONLY); + if (fd < 0) { + printf("Unable to open %s for reading: %s\n", fname.c_str(), strerror(errno)); + close(fd); + return std::vector(); + } + + while (1) { + std::string cmdstr; + int readbytes; + if (readbytes = read(fd, &buf, sizeof(buf)) > 0) { + memcpy(&structcmd, buf, sizeof(structcmd)); + assert(structcmd.type == TWENDADB || structcmd.type == TWIMG || structcmd.type == TWFN); + cmdstr = structcmd.type; + std::string cmdtype = cmdstr.substr(0, sizeof(structcmd.type) - 1); + if (cmdtype == TWENDADB) { + struct AdbBackupControlType endadb; + uint32_t crc, endadbcrc; + + memcpy(&endadb, buf, sizeof(endadb)); + endadbcrc = endadb.crc; + memset(&endadb.crc, 0, sizeof(endadb.crc)); + crc = crc32(0L, Z_NULL, 0); + crc = crc32(crc, (const unsigned char*) &endadb, sizeof(endadb)); + + if (crc == endadbcrc) { + break; + } + else { + printf("ADB TWENDADB crc header doesn't match\n"); + close(fd); + return std::vector(); + } + } + else if (cmdtype == TWIMG || cmdtype == TWFN) { + struct twfilehdr twfilehdr; + uint32_t crc, twfilehdrcrc; + + memcpy(&twfilehdr, buf, sizeof(twfilehdr)); + twfilehdrcrc = twfilehdr.crc; + memset(&twfilehdr.crc, 0, sizeof(twfilehdr.crc)); + + crc = crc32(0L, Z_NULL, 0); + crc = crc32(crc, (const unsigned char*) &twfilehdr, sizeof(twfilehdr)); + if (crc == twfilehdrcrc) { + std::string adbfile = twfilehdr.name; + int pos = adbfile.find_last_of("/") + 1; + adbfile = adbfile.substr(pos, adbfile.size()); + adb_partitions.push_back(adbfile); + } + else { + printf("ADB crc header doesn't match\n"); + close(fd); + return std::vector(); + } + } + } + } + close(fd); + return adb_partitions; +} + bool twadbbu::Write_ADB_Stream_Header(uint64_t partition_count) { struct AdbBackupStreamHeader twhdr; int adb_control_bu_fd; @@ -40,7 +135,7 @@ bool twadbbu::Write_ADB_Stream_Header(uint64_t partition_count) { memset(&twhdr, 0, sizeof(twhdr)); adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); if (adb_control_bu_fd < 0) { - printf("Cannot write to TW_ADB_BU_CONTROL.\n"); + printf("Cannot write to TW_ADB_BU_CONTROL: %s\n", strerror(errno)); return false; } @@ -52,7 +147,7 @@ bool twadbbu::Write_ADB_Stream_Header(uint64_t partition_count) { twhdr.crc = crc32(0L, Z_NULL, 0); twhdr.crc = crc32(twhdr.crc, (const unsigned char*) &twhdr, sizeof(twhdr)); if (write(adb_control_bu_fd, &twhdr, sizeof(twhdr)) < 0) { - printf("Cannot write to adb control channel\n"); + printf("Cannot write to adb control channel: %s\n", strerror(errno)); close(adb_control_bu_fd); return false; } @@ -67,7 +162,7 @@ bool twadbbu::Write_ADB_Stream_Trailer() { adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY); if (adb_control_bu_fd < 0) { - printf("Error opening adb_control_bu_fd\n"); + printf("Error opening adb_control_bu_fd: %s\n", strerror(errno)); return false; } strncpy(endadb.start_of_header, TWRP, sizeof(endadb.start_of_header)); @@ -75,7 +170,7 @@ bool twadbbu::Write_ADB_Stream_Trailer() { endadb.crc = crc32(0L, Z_NULL, 0); endadb.crc = crc32(endadb.crc, (const unsigned char*) &endadb, sizeof(endadb)); if (write(adb_control_bu_fd, &endadb, sizeof(endadb)) < 0) { - printf("Cannot write to ADB control.\n"); + printf("Cannot write to ADB control: %s\n", strerror(errno)); close(adb_control_bu_fd); return false; } @@ -97,10 +192,11 @@ bool twadbbu::Write_TWFN(std::string Backup_FileName, uint64_t file_size, bool u printf("Sending TWFN to adb\n"); if (write(adb_control_bu_fd, &twfilehdr, sizeof(twfilehdr)) < 1) { - printf("Cannot that write to adb_control_bu_fd\n"); + printf("Cannot that write to adb_control_bu_fd: %s\n", strerror(errno)); close(adb_control_bu_fd); return false; } + fsync(adb_control_bu_fd); close(adb_control_bu_fd); return true; } @@ -118,7 +214,7 @@ bool twadbbu::Write_TWIMG(std::string Backup_FileName, uint64_t file_size) { twimghdr.crc = crc32(twimghdr.crc, (const unsigned char*) &twimghdr, sizeof(twimghdr)); printf("Sending TWIMG to adb\n"); if (write(adb_control_bu_fd, &twimghdr, sizeof(twimghdr)) < 1) { - printf("Cannot write to adb control channel\n"); + printf("Cannot write to adb control channel: %s\n", strerror(errno)); return false; } @@ -168,7 +264,7 @@ bool twadbbu::Write_TWERROR() { twerror.crc = crc32(0L, Z_NULL, 0); twerror.crc = crc32(twerror.crc, (const unsigned char*) &twerror, sizeof(twerror)); if (write(adb_control_bu_fd, &twerror, sizeof(twerror)) < 0) { - printf("Cannot write to adb control channel"); + printf("Cannot write to adb control channel: %s\n", strerror(errno)); return false; } close(adb_control_bu_fd); diff --git a/adbbu/libtwadbbu.hpp b/adbbu/libtwadbbu.hpp index bcd8b6aa3..ff9a3eb7f 100644 --- a/adbbu/libtwadbbu.hpp +++ b/adbbu/libtwadbbu.hpp @@ -1,5 +1,5 @@ /* - Copyright 2013 to 2016 TeamWin + Copyright 2013 to 2017 TeamWin TWRP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or @@ -13,6 +13,8 @@ You should have received a copy of the GNU General Public License along with TWRP. If not, see . */ +#ifndef _LIBTWADBBU_HPP +#define _LIBTWADBBU_HPP #include #include @@ -26,6 +28,7 @@ #include #include #include +#include #include #include @@ -34,6 +37,8 @@ class twadbbu { public: + static bool Check_ADB_Backup_File(std::string fname); //Check if file is ADB Backup file + static std::vector Get_ADB_Backup_Files(std::string fname); //List ADB Files in String Vector static bool Write_ADB_Stream_Header(uint64_t partition_count); //Write ADB Stream Header to stream static bool Write_ADB_Stream_Trailer(); //Write ADB Stream Trailer to stream static bool Write_TWFN(std::string Backup_FileName, uint64_t file_size, bool use_compression); //Write a tar image to stream @@ -42,3 +47,5 @@ public: static bool Write_TWERROR(); //Write error message occurred to stream static bool Write_TWENDADB(); //Write ADB End-Of-Stream command to stream }; + +#endif //__LIBTWADBBU_HPP diff --git a/adbbu/twadbstream.h b/adbbu/twadbstream.h index 5fa6bde5d..3c73084d8 100644 --- a/adbbu/twadbstream.h +++ b/adbbu/twadbstream.h @@ -1,27 +1,33 @@ /* - TWRP is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. + TWRP is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - TWRP is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. + TWRP is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with TWRP. If not, see . + You should have received a copy of the GNU General Public License + along with TWRP. If not, see . */ #ifndef __TWADBSTREAM_H #define __TWADBSTREAM_H +#define TWRPARG "--twrp" +#define TWRP_BACKUP_ARG "backup" +#define TWRP_RESTORE_ARG "restore" +#define TWRP_STREAM_ARG "stream" #define TW_ADB_BACKUP "/tmp/twadbbackup" //FIFO for adb backup #define TW_ADB_RESTORE "/tmp/twadbrestore" //FIFO for adb restore #define TW_ADB_BU_CONTROL "/tmp/twadbbucontrol" //FIFO for sending control from TWRP to ADB Backup #define TW_ADB_TWRP_CONTROL "/tmp/twadbtwrpcontrol" //FIFO for sending control from ADB Backup to TWRP #define TWRP "TWRP" //Magic Value #define ADB_BU_MAX_ERROR 20 //Max amount of errors for while loops +#define ADB_BACKUP_OP "adbbackup" +#define ADB_RESTORE_OP "adbrestore" //ADB Backup Control Commands #define TWSTREAMHDR "twstreamheader" //TWRP Parititon Count Control diff --git a/adbbu/twrpback.cpp b/adbbu/twrpback.cpp index 8652de2ac..2c7ea6966 100644 --- a/adbbu/twrpback.cpp +++ b/adbbu/twrpback.cpp @@ -1,5 +1,5 @@ /* - Copyright 2013 to 2016 TeamWin + Copyright 2013 to 2017 TeamWin TWRP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or @@ -28,14 +28,17 @@ #include #include #include -#include #include +#include #include +#include +#include #include "twadbstream.h" #include "twrpback.hpp" #include "../twrpDigest/twrpDigest.hpp" #include "../twrpDigest/twrpMD5.hpp" +#include "../twrpAdbBuFifo.hpp" twrpback::twrpback(void) { read_fd = 0; @@ -47,11 +50,40 @@ twrpback::twrpback(void) { adb_write_fd = 0; ors_fd = 0; firstPart = true; + createFifos(); adbloginit(); } twrpback::~twrpback(void) { adblogfile.close(); + closeFifos(); +} + +void twrpback::createFifos(void) { + if (mkfifo(TW_ADB_BU_CONTROL, 0666) < 0) { + std::stringstream str; + str << strerror(errno); + adblogwrite("Unable to create TW_ADB_BU_CONTROL fifo: " + str.str() + "\n"); + } + if (mkfifo(TW_ADB_TWRP_CONTROL, 0666) < 0) { + std::stringstream str; + str << strerror(errno); + adblogwrite("Unable to create TW_ADB_TWRP_CONTROL fifo: " + str.str() + "\n"); + unlink(TW_ADB_BU_CONTROL); + } +} + +void twrpback::closeFifos(void) { + if (unlink(TW_ADB_BU_CONTROL) < 0) { + std::stringstream str; + str << strerror(errno); + adblogwrite("Unable to remove TW_ADB_BU_CONTROL: " + str.str()); + } + if (unlink(TW_ADB_TWRP_CONTROL) < 0) { + std::stringstream str; + str << strerror(errno); + adblogwrite("Unable to remove TW_ADB_TWRP_CONTROL: " + str.str()); + } } void twrpback::adbloginit(void) { @@ -119,14 +151,14 @@ int twrpback::backup(std::string command) { return -1; } - adblogwrite("opening ORS_INPUT_FILE\n"); - write_fd = open(ORS_INPUT_FILE, O_WRONLY); + adblogwrite("opening TW_ADB_FIFO\n"); + write_fd = open(TW_ADB_FIFO, O_WRONLY); while (write_fd < 0) { - write_fd = open(ORS_INPUT_FILE, O_WRONLY); + write_fd = open(TW_ADB_FIFO, O_WRONLY); usleep(10000); errctr++; if (errctr > ADB_BU_MAX_ERROR) { - adblogwrite("Unable to open ORS_INPUT_FILE\n"); + adblogwrite("Unable to open TW_ADB_FIFO\n"); close_backup_fds(); return -1; } @@ -144,14 +176,6 @@ int twrpback::backup(std::string command) { return -1; } - adblogwrite("opening ORS_OUTPUT_FILE\n"); - ors_fd = open(ORS_OUTPUT_FILE, O_RDONLY); - if (ors_fd < 0) { - adblogwrite("Unable to open ORS_OUTPUT_FILE\n"); - close_backup_fds(); - return -1; - } - memset(&result, 0, sizeof(result)); memset(&cmd, 0, sizeof(cmd)); @@ -263,7 +287,7 @@ int twrpback::backup(std::string command) { count = totalbytes / MAX_ADB_READ + 1; count = count * MAX_ADB_READ; - while ((bytes = read(adb_read_fd, &result, sizeof(result))) == MAX_ADB_READ) { + while ((bytes = read(adb_read_fd, &result, sizeof(result))) > 0) { totalbytes += bytes; char *writeresult = new char [bytes]; memcpy(writeresult, result, bytes); @@ -421,14 +445,14 @@ int twrpback::restore(void) { return -1; } - adblogwrite("opening ORS_INPUT_FILE\n"); - write_fd = open(ORS_INPUT_FILE, O_WRONLY); + adblogwrite("opening TW_ADB_FIFO\n"); + write_fd = open(TW_ADB_FIFO, O_WRONLY); while (write_fd < 0) { - write_fd = open(ORS_INPUT_FILE, O_WRONLY); + write_fd = open(TW_ADB_FIFO, O_WRONLY); errctr++; if (errctr > ADB_BU_MAX_ERROR) { - adblogwrite("Unable to open ORS_INPUT_FILE\n"); + adblogwrite("Unable to open TW_ADB_FIFO\n"); close_restore_fds(); return -1; } @@ -437,16 +461,7 @@ int twrpback::restore(void) { memset(operation, 0, sizeof(operation)); sprintf(operation, "adbrestore"); if (write(write_fd, operation, sizeof(operation)) != sizeof(operation)) { - adblogwrite("Unable to write to ORS_INPUT_FILE\n"); - close_restore_fds(); - return -1; - } - - ors_fd = open(ORS_OUTPUT_FILE, O_RDONLY); - if (ors_fd < 0) { - std::stringstream str; - str << strerror(errno); - adblogwrite("Unable to write to ORS_OUTPUT_FILE: " + str.str() + "\n"); + adblogwrite("Unable to write to TW_ADB_FIFO\n"); close_restore_fds(); return -1; } @@ -748,74 +763,25 @@ int twrpback::restore(void) { return 0; } -int main(int argc, char **argv) { - int index; - int ret = 0, pos = 0; - std::string command; - twrpback tw; - - tw.adblogwrite("Starting adb backup and restore\n"); - if (mkfifo(TW_ADB_BU_CONTROL, 0666) < 0) { - std::stringstream str; - str << strerror(errno); - tw.adblogwrite("Unable to create TW_ADB_BU_CONTROL fifo: " + str.str() + "\n"); - unlink(TW_ADB_BU_CONTROL); - return -1; - } - if (mkfifo(TW_ADB_TWRP_CONTROL, 0666) < 0) { - std::stringstream str; - str << strerror(errno); - tw.adblogwrite("Unable to create TW_ADB_TWRP_CONTROL fifo: " + str.str() + "\n"); - unlink(TW_ADB_TWRP_CONTROL); - unlink(TW_ADB_BU_CONTROL); - return -1; - } - - if (argc <= 1) { - tw.adblogwrite("No parameters given, exiting...\n"); - tw.close_restore_fds(); - return -1; - } - - command = argv[1]; - for (index = 2; index < argc; index++) { - command = command + " " + argv[index]; - } +void twrpback::streamFileForTWRP(void) { + adblogwrite("streamFileForTwrp" + streamFn + "\n"); +} - pos = command.find("backup"); - if (pos < 0) { - pos = command.find("restore"); - } - command.erase(0, pos); - command.erase(std::remove(command.begin(), command.end(), '\''), command.end()); - tw.adblogwrite("command: " + command + "\n"); - - if (command.substr(0, sizeof("backup") - 1) == "backup") { - tw.adblogwrite("Starting adb backup\n"); - if (isdigit(*argv[1])) - tw.adbd_fd = atoi(argv[1]); - else - tw.adbd_fd = 1; - ret = tw.backup(command); - } - else if (command.substr(0, sizeof("restore") - 1) == "restore") { - tw.adblogwrite("Starting adb restore\n"); - if (isdigit(*argv[1])) - tw.adbd_fd = atoi(argv[1]); - else - tw.adbd_fd = 0; - ret = tw.restore(); +void twrpback::setStreamFileName(std::string fn) { + streamFn = fn; + adbd_fd = open(fn.c_str(), O_RDONLY); + if (adbd_fd < 0) { + adblogwrite("Unable to open adb_fd\n"); + close(adbd_fd); + return; } - if (ret == 0) - tw.adblogwrite("Adb backup/restore completed\n"); - else - tw.adblogwrite("Adb backup/restore failed\n"); + restore(); +} - if (unlink(TW_ADB_BU_CONTROL) < 0) { - std::stringstream str; - str << strerror(errno); - tw.adblogwrite("Unable to remove TW_ADB_BU_CONTROL: " + str.str()); - } - unlink(TW_ADB_TWRP_CONTROL); - return ret; +void twrpback::threadStream(void) { + pthread_t thread; + ThreadPtr streamPtr = &twrpback::streamFileForTWRP; + PThreadPtr p = *(PThreadPtr*)&streamPtr; + pthread_create(&thread, NULL, p, this); + pthread_join(thread, NULL); } diff --git a/adbbu/twrpback.hpp b/adbbu/twrpback.hpp index 752d35ea1..1c6b09f15 100644 --- a/adbbu/twrpback.hpp +++ b/adbbu/twrpback.hpp @@ -1,5 +1,5 @@ /* - Copyright 2013 to 2016 TeamWin + Copyright 2013 to 2017 TeamWin TWRP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or @@ -14,23 +14,24 @@ along with TWRP. If not, see . */ -#include +#ifndef _TWRPBACK_HPP +#define _TWRPBACK_HPP -#include "../orscmd/orscmd.h" -#include "../variables.h" -#include "../twcommon.h" +#include class twrpback { public: int adbd_fd; // adbd data stream - twrpback(void); virtual ~twrpback(void); int backup(std::string command); // adb backup stream int restore(void); // adb restore stream void adblogwrite(std::string writemsg); // adb debugging log function - void close_backup_fds(); // close backup resources - void close_restore_fds(); // close restore resources + void createFifos(void); // create fifos needed for adb backup + void closeFifos(void); // close created fifos + void streamFileForTWRP(void); // stream file to twrp via bu + void setStreamFileName(std::string fn); // tell adb backup what file to load on storage + void threadStream(void); // thread bu for streaming private: int read_fd; // ors input fd @@ -45,5 +46,12 @@ private: char cmd[512]; // store result of commands char operation[512]; // operation to send to ors std::ofstream adblogfile; // adb stream log file + std::string streamFn; + typedef void (twrpback::*ThreadPtr)(void); + typedef void* (*PThreadPtr)(void *); void adbloginit(void); // setup adb log stream file + void close_backup_fds(); // close backup resources + void close_restore_fds(); // close restore resources }; + +#endif // _TWRPBACK_HPP diff --git a/gui/action.cpp b/gui/action.cpp index 05ae46515..039c4ef43 100644 --- a/gui/action.cpp +++ b/gui/action.cpp @@ -566,6 +566,7 @@ int GUIAction::reload(std::string arg __unused) int GUIAction::readBackup(std::string arg __unused) { string Restore_Name; + DataManager::GetValue("tw_restore", Restore_Name); PartitionManager.Set_Restore_Files(Restore_Name); return 0; @@ -1192,6 +1193,18 @@ int GUIAction::nandroid(std::string arg) string auto_gen = gui_lookup("auto_generate", "(Auto Generate)"); if (Backup_Name == auto_gen || Backup_Name == gui_lookup("curr_date", "(Current Date)") || Backup_Name == "0" || Backup_Name == "(" || PartitionManager.Check_Backup_Name(true) == 0) { ret = PartitionManager.Run_Backup(false); + DataManager::SetValue("tw_encrypt_backup", 0); // reset value so we don't encrypt every subsequent backup + if (!PartitionManager.stop_backup.get_value()) { + if (ret == false) + ret = 1; // 1 for failure + else + ret = 0; // 0 for success + DataManager::SetValue("tw_cancel_backup", 0); + } else { + DataManager::SetValue("tw_cancel_backup", 1); + gui_msg("backup_cancel=Backup Cancelled"); + ret = 0; + } } else { operation_end(1); return -1; @@ -1199,25 +1212,28 @@ int GUIAction::nandroid(std::string arg) DataManager::SetValue(TW_BACKUP_NAME, auto_gen); } else if (arg == "restore") { string Restore_Name; + int gui_adb_backup; + DataManager::GetValue("tw_restore", Restore_Name); - ret = PartitionManager.Run_Restore(Restore_Name); + DataManager::GetValue("tw_enable_adb_backup", gui_adb_backup); + if (gui_adb_backup) { + DataManager::SetValue("tw_operation_state", 1); + if (TWFunc::stream_adb_backup(Restore_Name) == 0) + ret = 0; // success + else + ret = 1; // failure + DataManager::SetValue("tw_enable_adb_backup", 0); + ret = 0; // assume success??? + } else { + if (PartitionManager.Run_Restore(Restore_Name)) + ret = 0; // success + else + ret = 1; // failure + } } else { - operation_end(1); + operation_end(1); // invalid arg specified, fail return -1; } - DataManager::SetValue("tw_encrypt_backup", 0); - if (!PartitionManager.stop_backup.get_value()) { - if (ret == false) - ret = 1; // 1 for failure - else - ret = 0; // 0 for success - DataManager::SetValue("tw_cancel_backup", 0); - } - else { - DataManager::SetValue("tw_cancel_backup", 1); - gui_msg("backup_cancel=Backup Cancelled"); - ret = 0; - } operation_end(ret); return ret; } diff --git a/gui/fileselector.cpp b/gui/fileselector.cpp index a992b80ea..c4aaab168 100644 --- a/gui/fileselector.cpp +++ b/gui/fileselector.cpp @@ -30,6 +30,7 @@ extern "C" { #include "objects.hpp" #include "../data.hpp" #include "../twrp-functions.hpp" +#include "../adbbu/libtwadbbu.hpp" int GUIFileSelector::mSortOrder = 0; @@ -270,7 +271,10 @@ int GUIFileSelector::GetFileList(const std::string folder) mFolderList.push_back(data); } else if (data.fileType == DT_REG || data.fileType == DT_LNK || data.fileType == DT_BLK) { if (mExtn.empty() || (data.fileName.length() > mExtn.length() && data.fileName.substr(data.fileName.length() - mExtn.length()) == mExtn)) { - mFileList.push_back(data); + if (mExtn == ".ab" && twadbbu::Check_ADB_Backup_File(path)) + mFolderList.push_back(data); + else + mFileList.push_back(data); } } } @@ -354,8 +358,8 @@ void GUIFileSelector::NotifySelect(size_t item_selected) cwd += str; } - if (mShowNavFolders == 0 && mShowFiles == 0) { - // nav folders and files are disabled, this is probably the restore list and we need to save chosen location to mVariable instead of mPathVar + if (mShowNavFolders == 0 && (mShowFiles == 0 || mExtn == ".ab")) { + // this is probably the restore list and we need to save chosen location to mVariable instead of mPathVar DataManager::SetValue(mVariable, cwd); } else { // We are changing paths, so we need to set mPathVar diff --git a/gui/gui.cpp b/gui/gui.cpp index 369b6b897..a70dadfd2 100644 --- a/gui/gui.cpp +++ b/gui/gui.cpp @@ -462,14 +462,6 @@ static void ors_command_read() gui_set_FILE(orsout); PageManager::GetResources()->DumpStrings(); ors_command_done(); - //check to see if we should show backup page for parsing adbbackup partitions - } else if (strlen(command) == 23 && strncmp(command, "adbbackup", 9) == 0) { - gui_set_FILE(orsout); - DataManager::SetValue("tw_action", "twcmd"); - DataManager::SetValue("tw_action_param", command); - DataManager::SetValue("tw_enable_adb_backup", 1); - gui_changePage("backup"); - ors_command_done(); } else { // mirror output messages gui_set_FILE(orsout); diff --git a/gui/theme/common/landscape.xml b/gui/theme/common/landscape.xml index c3d89fe2d..f460e6fee 100644 --- a/gui/theme/common/landscape.xml +++ b/gui/theme/common/landscape.xml @@ -2047,7 +2047,7 @@ {@restore_sel_pack_fs=Select Package to Restore:} - + @@ -2273,6 +2273,7 @@ + {@restore_enable_digest_chk=Enable Digest Verification of Backup Files} diff --git a/gui/theme/common/portrait.xml b/gui/theme/common/portrait.xml index f163bea8b..0d1d6d8a2 100644 --- a/gui/theme/common/portrait.xml +++ b/gui/theme/common/portrait.xml @@ -2209,7 +2209,7 @@ {@restore_sel_pack_fs=Select Package to Restore:} - + @@ -2429,6 +2429,7 @@ + {@restore_enable_digest_chk=Enable Digest Verification of Backup Files} diff --git a/gui/theme/common/watch.xml b/gui/theme/common/watch.xml index d5ef86972..152818e72 100644 --- a/gui/theme/common/watch.xml +++ b/gui/theme/common/watch.xml @@ -2551,7 +2551,7 @@ %tw_storage_display_name% - + @@ -2807,6 +2807,7 @@ + diff --git a/openrecoveryscript.cpp b/openrecoveryscript.cpp index 023543870..92cac0791 100644 --- a/openrecoveryscript.cpp +++ b/openrecoveryscript.cpp @@ -1,5 +1,5 @@ /* - Copyright 2016 TeamWin + Copyright 2003 to 2017 TeamWin This file is part of TWRP/TeamWin Recovery Project. TWRP is free software: you can redistribute it and/or modify @@ -51,7 +51,6 @@ #include "gui/gui.hpp" #include "gui/pages.hpp" #include "orscmd/orscmd.h" -#include "adbbu/libtwadbbu.hpp" #include "twinstall.h" extern "C" { #include "gui/gui.h" @@ -292,15 +291,6 @@ int OpenRecoveryScript::run_script_file(void) { ret_val = 1; else gui_msg("done=Done."); - } else if (strncmp(command, "adbbackup", 9) == 0) { - ret_val = Backup_ADB_Command(value); - if (ret_val == 1) { - twadbbu::Write_TWERROR(); - gui_err("adbbackup_error=Error with ADB Backup. Quitting..."); - } - } else if (strcmp(command, "adbrestore") == 0) { - LOGINFO("running adb restore\n"); - ret_val = Restore_ADB_Backup(); } else if (strcmp(command, "remountrw") == 0) { ret_val = remountrw(); } else if (strcmp(command, "mount") == 0) { @@ -509,72 +499,6 @@ int OpenRecoveryScript::Install_Command(string Zip) { return ret_val; } -int OpenRecoveryScript::Backup_ADB_Command(std::string Options) { - std::vector args; - std::string Backup_List; - bool adbbackup = true, ret = false; - std::string rmopt = "--"; - - std::replace(Options.begin(), Options.end(), ':', ' '); - args = TWFunc::Split_String(Options, " "); - - DataManager::SetValue(TW_USE_COMPRESSION_VAR, 0); - DataManager::SetValue(TW_SKIP_DIGEST_GENERATE_VAR, 0); - - if (args[1].compare("--twrp") != 0) { - gui_err("twrp_adbbu_option=--twrp option is required to enable twrp adb backup"); - sleep(2); - return 1; - } - - for (unsigned i = 2; i < args.size(); i++) { - int compress; - - std::string::size_type size = args[i].find(rmopt); - if (size != std::string::npos) - args[i].erase(size, rmopt.length()); - - if (args[i].compare("compress") == 0) { - gui_msg("compression_on=Compression is on"); - DataManager::SetValue(TW_USE_COMPRESSION_VAR, 1); - continue; - } - DataManager::GetValue(TW_USE_COMPRESSION_VAR, compress); - gui_print("%s\n", args[i].c_str()); - std::string path; - path = "/" + args[i]; - TWPartition* part = PartitionManager.Find_Partition_By_Path(path); - if (part) { - Backup_List += path; - Backup_List += ";"; - } - else { - gui_msg(Msg(msg::kError, "partition_not_found=path: {1} not found in partition list")(path)); - return 1; - } - } - - if (Backup_List.empty()) { - DataManager::GetValue("tw_backup_list", Backup_List); - if (Backup_List.empty()) { - gui_err("no_partition_selected=No partitions selected for backup."); - return 1; - } - } - else - DataManager::SetValue("tw_backup_list", Backup_List); - - ret = PartitionManager.Run_Backup(adbbackup); - DataManager::SetValue(TW_BACKUP_NAME, gui_lookup("auto_generate", "(Auto Generate)")); - if (!ret) { - gui_err("backup_fail=Backup failed"); - return 1; - } - gui_msg("backup_complete=Backup Complete"); - sleep(2); //give time for user to see messages on console - return 0; -} - string OpenRecoveryScript::Locate_Zip_File(string Zip, string Storage_Root) { string Path = TWFunc::Get_Path(Zip); string File = TWFunc::Get_Filename(Zip); @@ -742,191 +666,6 @@ void OpenRecoveryScript::Run_CLI_Command(const char* command) { LOGINFO("Done reading ORS command from command line\n"); } -int OpenRecoveryScript::Restore_ADB_Backup(void) { - bool breakloop = false; - int partition_count = 0; - std::string Restore_Name; - struct AdbBackupFileTrailer adbmd5; - struct PartitionSettings part_settings; - int adb_control_twrp_fd; - int adb_control_bu_fd, ret = 0; - char cmd[512]; - - part_settings.total_restore_size = 0; - - PartitionManager.Mount_All_Storage(); - DataManager::SetValue(TW_SKIP_DIGEST_CHECK_VAR, 0); - - LOGINFO("opening TW_ADB_BU_CONTROL\n"); - adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); - if (adb_control_bu_fd < 0) { - LOGERR("Error opening TW_ADB_BU_CONTROL\n"); - return -1; - } - LOGINFO("opening TW_ADB_TWRP_CONTROL\n"); - adb_control_twrp_fd = open(TW_ADB_TWRP_CONTROL, O_RDONLY | O_NONBLOCK); - if (adb_control_twrp_fd < 0) { - LOGERR("Error opening TW_ADB_TWRP_CONTROL\n"); - close(adb_control_bu_fd); - return -1; - } - - memset(&adbmd5, 0, sizeof(adbmd5)); - - while (!breakloop) { - memset(&cmd, 0, sizeof(cmd)); - if (read(adb_control_twrp_fd, cmd, sizeof(cmd)) > 0) { - struct AdbBackupControlType cmdstruct; - - memset(&cmdstruct, 0, sizeof(cmdstruct)); - memcpy(&cmdstruct, cmd, sizeof(cmdstruct)); - std::string cmdstr(cmdstruct.type); - std::string cmdtype = cmdstr.substr(0, sizeof(cmdstruct.type) - 1); - if (cmdstr.substr(0, sizeof(cmdstruct.type) - 1) == TWSTREAMHDR) { - struct AdbBackupStreamHeader twhdr; - memcpy(&twhdr, cmd, sizeof(cmd)); - LOGINFO("ADB Partition count: %" PRIu64 "\n", twhdr.partition_count); - LOGINFO("ADB version: %" PRIu64 "\n", twhdr.version); - if (twhdr.version != ADB_BACKUP_VERSION) { - LOGERR("Incompatible adb backup version!\n"); - breakloop = false; - break; - } - partition_count = twhdr.partition_count; - } - else if (cmdtype == MD5TRAILER) { - LOGINFO("Restoring MD5TRAILER\n"); - memcpy(&adbmd5, cmd, sizeof(cmd)); - } - else if (cmdtype == TWMD5) { - struct AdbBackupFileTrailer md5check; - LOGINFO("Restoring TWMD5\n"); - - memset(&md5check, 0, sizeof(md5check)); - memcpy(&md5check, cmd, sizeof(cmd)); - if (strcmp(md5check.md5, adbmd5.md5) != 0) { - LOGERR("md5 doesn't match!\n"); - LOGERR("file md5: %s\n", adbmd5.md5); - LOGERR("check md5: %s\n", md5check.md5); - breakloop = true; - ret = 1; - break; - } - else { - LOGINFO("adbrestore md5 matches\n"); - LOGINFO("adbmd5.md5: %s\n", adbmd5.md5); - LOGINFO("md5check.md5: %s\n", md5check.md5); - } - } - else if (cmdtype == TWENDADB) { - LOGINFO("received TWENDADB\n"); - breakloop = true; - break; - } - else { - struct twfilehdr twimghdr; - memcpy(&twimghdr, cmd, sizeof(cmd)); - std::string cmdstr(twimghdr.type); - Restore_Name = twimghdr.name; - part_settings.total_restore_size = twimghdr.size; - if (cmdtype == TWIMG) { - LOGINFO("ADB Type: %s\n", twimghdr.type); - LOGINFO("ADB Restore_Name: %s\n", Restore_Name.c_str()); - LOGINFO("ADB Restore_size: %" PRIu64 "\n", part_settings.total_restore_size); - string compression = (twimghdr.compressed == 1) ? "compressed" : "uncompressed"; - LOGINFO("ADB compression: %s\n", compression.c_str()); - std::string Backup_FileName; - std::size_t pos = Restore_Name.find_last_of("/"); - std::string path = "/" + Restore_Name.substr(pos, Restore_Name.size()); - pos = path.find_first_of("."); - path = path.substr(0, pos); - if (path.substr(0,1).compare("//")) { - path = path.substr(1, path.size()); - } - - pos = Restore_Name.find_last_of("/"); - Backup_FileName = Restore_Name.substr(pos + 1, Restore_Name.size()); - part_settings.Part = PartitionManager.Find_Partition_By_Path(path); - part_settings.Backup_Folder = path; - part_settings.partition_count = partition_count; - part_settings.adbbackup = true; - part_settings.adb_compression = twimghdr.compressed; - part_settings.PM_Method = PM_RESTORE; - ProgressTracking progress(part_settings.total_restore_size); - part_settings.progress = &progress; - if (!PartitionManager.Restore_Partition(&part_settings)) { - LOGERR("ADB Restore failed.\n"); - close(adb_control_twrp_fd); - close(adb_control_bu_fd); - return 1; - } - } - else if (cmdtype == TWFN) { - LOGINFO("ADB Type: %s\n", twimghdr.type); - LOGINFO("ADB Restore_Name: %s\n", Restore_Name.c_str()); - LOGINFO("ADB Restore_size: %" PRIi64 "\n", part_settings.total_restore_size); - string compression = (twimghdr.compressed == 1) ? "compressed" : "uncompressed"; - LOGINFO("ADB compression: %s\n", compression.c_str()); - std::string Backup_FileName; - std::size_t pos = Restore_Name.find_last_of("/"); - std::string path = "/" + Restore_Name.substr(pos, Restore_Name.size()); - pos = path.find_first_of("."); - path = path.substr(0, pos); - if (path.substr(0,1).compare("//")) { - path = path.substr(1, path.size()); - } - - pos = Restore_Name.find_last_of("/"); - Backup_FileName = Restore_Name.substr(pos + 1, Restore_Name.size()); - pos = Restore_Name.find_last_of("/"); - part_settings.Part = PartitionManager.Find_Partition_By_Path(path); - - if (path.compare("/system") == 0) { - if (part_settings.Part->Is_Read_Only()) { - struct AdbBackupControlType twerror; - strncpy(twerror.start_of_header, TWRP, sizeof(twerror.start_of_header)); - strncpy(twerror.type, TWERROR, sizeof(twerror.type)); - memset(twerror.space, 0, sizeof(twerror.space)); - twerror.crc = crc32(0L, Z_NULL, 0); - twerror.crc = crc32(twerror.crc, (const unsigned char*) &twerror, sizeof(twerror)); - if (write(adb_control_bu_fd, &twerror, sizeof(twerror)) < 0) { - LOGERR("Cannot write to ADB_CONTROL_BU_FD: %s\n", strerror(errno)); - } - gui_msg(Msg(msg::kError, "restore_read_only=Cannot restore {1} -- mounted read only.")(part_settings.Part->Backup_Display_Name)); - close(adb_control_twrp_fd); - close(adb_control_bu_fd); - return 1; - - } - } - part_settings.partition_count = partition_count; - part_settings.adbbackup = true; - part_settings.adb_compression = twimghdr.compressed; - part_settings.Part->Set_Backup_FileName(part_settings.Part->Get_Backup_Name() + "." + part_settings.Part->Current_File_System + ".win"); - part_settings.total_restore_size += part_settings.Part->Get_Restore_Size(&part_settings); - part_settings.PM_Method = PM_RESTORE; - ProgressTracking progress(part_settings.total_restore_size); - part_settings.progress = &progress; - if (!PartitionManager.Restore_Partition(&part_settings)) { - LOGERR("ADB Restore failed.\n"); - close(adb_control_twrp_fd); - close(adb_control_bu_fd); - return 1; - } - } - } - } - } - close(adb_control_twrp_fd); - close(adb_control_bu_fd); - gui_msg("restore_complete=Restore Complete"); - - if (!twadbbu::Write_TWENDADB()) - ret = 1; - sleep(2); //give time for user to see messages on console - return ret; -} - int OpenRecoveryScript::remountrw(void) { bool remount_system = PartitionManager.Is_Mounted_By_Path("/system"); diff --git a/openrecoveryscript.hpp b/openrecoveryscript.hpp index f442746c7..08062239d 100644 --- a/openrecoveryscript.hpp +++ b/openrecoveryscript.hpp @@ -1,5 +1,5 @@ /* - Copyright 2012 bigbiff/Dees_Troy TeamWin + Copyright 2012 - 2017 TeamWin This file is part of TWRP/TeamWin Recovery Project. TWRP is free software: you can redistribute it and/or modify @@ -40,8 +40,6 @@ public: static int Run_OpenRecoveryScript_Action(); // Actually runs the ORS scripts for the GUI action static void Call_After_CLI_Command(VoidFunction fn) { call_after_cli_command = fn; } static void Run_CLI_Command(const char* command); // Runs a command for orscmd (twrp binary) - static int Backup_ADB_Command(string Options); // Runs adbbackup - static int Restore_ADB_Backup(); // Restore adb backup through ors static int remountrw(); // Remount system and vendor rw }; diff --git a/partition.cpp b/partition.cpp index 44403d845..4157e9791 100644 --- a/partition.cpp +++ b/partition.cpp @@ -2249,7 +2249,7 @@ bool TWPartition::Raw_Read_Write(PartitionSettings *part_settings) { gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(destfn.c_str())(strerror(errno))); goto exit; } - + LOGINFO("Reading '%s', writing '%s'\n", srcfn.c_str(), destfn.c_str()); if (part_settings->adbbackup) { diff --git a/partitionmanager.cpp b/partitionmanager.cpp index 9b1c1c926..e896cee2c 100644 --- a/partitionmanager.cpp +++ b/partitionmanager.cpp @@ -1,5 +1,5 @@ /* - Copyright 2014 to 2016 TeamWin + Copyright 2014 to 2017 TeamWin This file is part of TWRP/TeamWin Recovery Project. TWRP is free software: you can redistribute it and/or modify @@ -667,10 +667,6 @@ int TWPartitionManager::Run_Backup(bool adbbackup) { part_settings.file_bytes = 0; part_settings.PM_Method = PM_BACKUP; - DataManager::GetValue("tw_enable_adb_backup", gui_adb_backup); - if (gui_adb_backup == true) - adbbackup = true; - part_settings.adbbackup = adbbackup; time(&total_start); @@ -865,6 +861,8 @@ bool TWPartitionManager::Restore_Partition(PartitionSettings *part_settings) { time_t Start, Stop; if (part_settings->adbbackup) { + std::string partName = part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win"; + LOGINFO("setting backup name: %s\n", partName.c_str()); part_settings->Part->Set_Backup_FileName(part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win"); } @@ -876,7 +874,7 @@ bool TWPartitionManager::Restore_Partition(PartitionSettings *part_settings) { TWFunc::SetPerformanceMode(false); return false; } - if (part_settings->Part->Has_SubPartition) { + if (part_settings->Part->Has_SubPartition && !part_settings->adbbackup) { std::vector::iterator subpart; TWPartition *parentPart = part_settings->Part; @@ -884,6 +882,7 @@ bool TWPartitionManager::Restore_Partition(PartitionSettings *part_settings) { part_settings->Part = *subpart; if ((*subpart)->Is_SubPartition && (*subpart)->SubPartition_Of == parentPart->Mount_Point) { part_settings->Part = (*subpart); + part_settings->Part->Set_Backup_FileName(part_settings->Part->Backup_Name + "." + part_settings->Part->Current_File_System + ".win"); if (!(*subpart)->Restore(part_settings)) { TWFunc::SetPerformanceMode(false); return false; @@ -1013,93 +1012,114 @@ void TWPartitionManager::Set_Restore_Files(string Restore_Name) { // Start with the default values string Restore_List; bool get_date = true, check_encryption = true; + bool adbbackup = false; DataManager::SetValue("tw_restore_encrypted", 0); + if (twadbbu::Check_ADB_Backup_File(Restore_Name)) { + vector adb_files; + adb_files = twadbbu::Get_ADB_Backup_Files(Restore_Name); + for (unsigned int i = 0; i < adb_files.size(); ++i) { + string adb_restore_file = adb_files.at(i); + std::size_t pos = adb_restore_file.find_first_of("."); + std::string path = "/" + adb_restore_file.substr(0, pos); + Restore_List = path + ";"; + TWPartition* Part = Find_Partition_By_Path(path); + Part->Backup_FileName = TWFunc::Get_Filename(adb_restore_file); + adbbackup = true; + } + DataManager::SetValue("tw_enable_adb_backup", 1); + } + else { + DIR* d; + d = opendir(Restore_Name.c_str()); + if (d == NULL) + { + gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Name)(strerror(errno))); + return; + } - DIR* d; - d = opendir(Restore_Name.c_str()); - if (d == NULL) - { - gui_msg(Msg(msg::kError, "error_opening_strerr=Error opening: '{1}' ({2})")(Restore_Name)(strerror(errno))); - return; - } - - struct dirent* de; - while ((de = readdir(d)) != NULL) - { - // Strip off three components - char str[256]; - char* label; - char* fstype = NULL; - char* extn = NULL; - char* ptr; - - strcpy(str, de->d_name); - if (strlen(str) <= 2) - continue; + struct dirent* de; + while ((de = readdir(d)) != NULL) + { + // Strip off three components + char str[256]; + char* label; + char* fstype = NULL; + char* extn = NULL; + char* ptr; + + strcpy(str, de->d_name); + if (strlen(str) <= 2) + continue; + + if (get_date) { + char file_path[255]; + struct stat st; + + strcpy(file_path, Restore_Name.c_str()); + strcat(file_path, "/"); + strcat(file_path, str); + stat(file_path, &st); + string backup_date = ctime((const time_t*)(&st.st_mtime)); + DataManager::SetValue(TW_RESTORE_FILE_DATE, backup_date); + get_date = false; + } - if (get_date) { - char file_path[255]; - struct stat st; + label = str; + ptr = label; + while (*ptr && *ptr != '.') ptr++; + if (*ptr == '.') + { + *ptr = 0x00; + ptr++; + fstype = ptr; + } + while (*ptr && *ptr != '.') ptr++; + if (*ptr == '.') + { + *ptr = 0x00; + ptr++; + extn = ptr; + } - strcpy(file_path, Restore_Name.c_str()); - strcat(file_path, "/"); - strcat(file_path, str); - stat(file_path, &st); - string backup_date = ctime((const time_t*)(&st.st_mtime)); - DataManager::SetValue(TW_RESTORE_FILE_DATE, backup_date); - get_date = false; - } + if (fstype == NULL || extn == NULL || strcmp(fstype, "log") == 0) continue; + int extnlength = strlen(extn); + if (extnlength != 3 && extnlength != 6) continue; + if (extnlength >= 3 && strncmp(extn, "win", 3) != 0) continue; + //if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue; + + if (check_encryption) { + string filename = Restore_Name + "/"; + filename += de->d_name; + if (TWFunc::Get_File_Type(filename) == 2) { + LOGINFO("'%s' is encrypted\n", filename.c_str()); + DataManager::SetValue("tw_restore_encrypted", 1); + } + } + if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue; - label = str; - ptr = label; - while (*ptr && *ptr != '.') ptr++; - if (*ptr == '.') - { - *ptr = 0x00; - ptr++; - fstype = ptr; - } - while (*ptr && *ptr != '.') ptr++; - if (*ptr == '.') - { - *ptr = 0x00; - ptr++; - extn = ptr; - } - - if (fstype == NULL || extn == NULL || strcmp(fstype, "log") == 0) continue; - int extnlength = strlen(extn); - if (extnlength != 3 && extnlength != 6) continue; - if (extnlength >= 3 && strncmp(extn, "win", 3) != 0) continue; - //if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue; - - if (check_encryption) { - string filename = Restore_Name + "/"; - filename += de->d_name; - if (TWFunc::Get_File_Type(filename) == 2) { - LOGINFO("'%s' is encrypted\n", filename.c_str()); - DataManager::SetValue("tw_restore_encrypted", 1); + TWPartition* Part = Find_Partition_By_Path(label); + if (Part == NULL) + { + gui_msg(Msg(msg::kError, "unable_locate_part_backup_name=Unable to locate partition by backup name: '{1}'")(label)); + continue; } - } - if (extnlength == 6 && strncmp(extn, "win000", 6) != 0) continue; - TWPartition* Part = Find_Partition_By_Path(label); - if (Part == NULL) - { - gui_msg(Msg(msg::kError, "unable_locate_part_backup_name=Unable to locate partition by backup name: '{1}'")(label)); - continue; - } + Part->Backup_FileName = de->d_name; + if (strlen(extn) > 3) { + Part->Backup_FileName.resize(Part->Backup_FileName.size() - strlen(extn) + 3); + } - Part->Backup_FileName = de->d_name; - if (strlen(extn) > 3) { - Part->Backup_FileName.resize(Part->Backup_FileName.size() - strlen(extn) + 3); + if (!Part->Is_SubPartition) + Restore_List += Part->Backup_Path + ";"; } + closedir(d); + } - if (!Part->Is_SubPartition) - Restore_List += Part->Backup_Path + ";"; + if (adbbackup) { + Restore_List = "ADB_Backup;"; + adbbackup = false; } - closedir(d); // Set the final value DataManager::SetValue("tw_restore_list", Restore_List); @@ -1953,12 +1973,19 @@ void TWPartitionManager::Get_Partition_List(string ListType, std::vectorpush_back(part); + break; + } if ((restore_part = Find_Partition_By_Path(restore_path)) != NULL) { if ((restore_part->Backup_Name == "recovery" && !restore_part->Can_Be_Backed_Up) || restore_part->Is_SubPartition) { // Don't allow restore of recovery (causes problems on some devices) // Don't add subpartitions to the list of items } else { - struct PartitionList part; part.Display_Name = restore_part->Backup_Display_Name; part.Mount_Point = restore_part->Backup_Path; part.selected = 1; diff --git a/partitions.hpp b/partitions.hpp index 61bf7e291..30a025a27 100644 --- a/partitions.hpp +++ b/partitions.hpp @@ -1,5 +1,5 @@ /* - Copyright 2014 to 2016 TeamWin + Copyright 2014 to 2017 TeamWin This file is part of TWRP/TeamWin Recovery Project. TWRP is free software: you can redistribute it and/or modify diff --git a/twinstall.cpp b/twinstall.cpp index 0aaab4534..ab715291a 100644 --- a/twinstall.cpp +++ b/twinstall.cpp @@ -1,5 +1,5 @@ /* - Copyright 2012 to 2016 bigbiff/Dees_Troy TeamWin + Copyright 2012 to 2017 bigbiff/Dees_Troy TeamWin This file is part of TWRP/TeamWin Recovery Project. TWRP is free software: you can redistribute it and/or modify diff --git a/twrp-functions.cpp b/twrp-functions.cpp index eabcc53e1..d7c9c2cab 100644 --- a/twrp-functions.cpp +++ b/twrp-functions.cpp @@ -35,6 +35,7 @@ #include #include #include +#include #include #include "twrp-functions.hpp" #include "twcommon.h" @@ -857,6 +858,10 @@ void TWFunc::Auto_Generate_Backup_Name() { DataManager::SetValue(TW_BACKUP_NAME, Get_Current_Date()); return; } + else { + //remove periods from build display so it doesn't confuse the extension code + propvalue.erase(remove(propvalue.begin(), propvalue.end(), '.'), propvalue.end()); + } string Backup_Name = Get_Current_Date(); Backup_Name += "_" + propvalue; if (Backup_Name.size() > MAX_BACKUP_NAME_LEN) @@ -1122,4 +1127,23 @@ void TWFunc::copy_kernel_log(string curr_storage) { gui_msg(Msg("copy_kernel_log=Copied kernel log to {1}")(dmesgDst)); tw_set_default_metadata(dmesgDst.c_str()); } + +bool TWFunc::isNumber(string strtocheck) { + int num = 0; + std::istringstream iss(strtocheck); + + if (!(iss >> num).fail()) + return true; + else + return false; +} + +int TWFunc::stream_adb_backup(string &Restore_Name) { + string cmd = "/sbin/bu --twrp stream " + Restore_Name; + LOGINFO("stream_adb_backup: %s\n", cmd.c_str()); + int ret = TWFunc::Exec_Cmd(cmd); + if (ret != 0) + return -1; + return ret; +} #endif // ndef BUILD_TWRPTAR_MAIN diff --git a/twrp-functions.hpp b/twrp-functions.hpp index 1f6b9b177..66781bb32 100644 --- a/twrp-functions.hpp +++ b/twrp-functions.hpp @@ -98,6 +98,8 @@ public: static void Disable_Stock_Recovery_Replace(); // Disable stock ROMs from replacing TWRP with stock recovery static unsigned long long IOCTL_Get_Block_Size(const char* block_device); static void copy_kernel_log(string curr_storage); // Copy Kernel Log to Current Storage (PSTORE/KMSG) + static bool isNumber(string strtocheck); // return true if number, false if not a number + static int stream_adb_backup(string &Restore_Name); // Tell ADB Backup to Stream to TWRP from GUI selection private: static void Copy_Log(string Source, string Destination); diff --git a/twrp.cpp b/twrp.cpp index b68e321b9..8c2a24f22 100644 --- a/twrp.cpp +++ b/twrp.cpp @@ -45,6 +45,7 @@ extern "C" { #include "partitions.hpp" #include "openrecoveryscript.hpp" #include "variables.h" +#include "twrpAdbBuFifo.hpp" #ifdef TW_USE_NEW_MINADBD #include "minadbd/minadbd.h" #else @@ -330,6 +331,7 @@ int main(int argc, char **argv) { // Check if system has never been changed TWPartition* sys = PartitionManager.Find_Partition_By_Path("/system"); TWPartition* ven = PartitionManager.Find_Partition_By_Path("/vendor"); + if (sys) { if ((DataManager::GetIntValue("tw_mount_system_ro") == 0 && sys->Check_Lifetime_Writes() == 0) || DataManager::GetIntValue("tw_mount_system_ro") == 2) { if (DataManager::GetIntValue("tw_never_show_system_ro_page") == 0) { @@ -351,6 +353,9 @@ int main(int argc, char **argv) { } } #endif + twrpAdbBuFifo *adb_bu_fifo = new twrpAdbBuFifo(); + adb_bu_fifo->threadAdbBuFifo(); + // Launch the main GUI gui_start(); @@ -379,6 +384,7 @@ int main(int argc, char **argv) { // Reboot TWFunc::Update_Intent_File(Send_Intent); + delete adb_bu_fifo; TWFunc::Update_Log_File(); gui_msg(Msg("rebooting=Rebooting...")); string Reboot_Arg; diff --git a/twrpAdbBuFifo.cpp b/twrpAdbBuFifo.cpp new file mode 100644 index 000000000..db34c5ac2 --- /dev/null +++ b/twrpAdbBuFifo.cpp @@ -0,0 +1,336 @@ +/* + Copyright 2013 to 2017 TeamWin + This file is part of TWRP/TeamWin Recovery Project. + + TWRP is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + TWRP is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with TWRP. If not, see . +*/ + +#define __STDC_FORMAT_MACROS 1 +#include +#include +#include +#include +#include +#include +#include "twrpAdbBuFifo.hpp" +#include "twcommon.h" +#include "data.hpp" +#include "variables.h" +#include "partitions.hpp" +#include "twrp-functions.hpp" +#include "gui/gui.hpp" +#include "gui/objects.hpp" +#include "gui/pages.hpp" +#include "adbbu/twadbstream.h" +#include "adbbu/libtwadbbu.hpp" + +twrpAdbBuFifo::twrpAdbBuFifo(void) { + unlink(TW_ADB_FIFO); +} + +bool twrpAdbBuFifo::Check_Adb_Fifo_For_Events(void) { + char cmd[512]; + + memset(&cmd, 0, sizeof(cmd)); + + if (read(adb_fifo_fd, &cmd, sizeof(cmd)) > 0) { + LOGINFO("adb backup cmd: %s\n", cmd); + std::string cmdcheck(cmd); + cmdcheck = cmdcheck.substr(0, strlen(ADB_BACKUP_OP)); + std::string Options(cmd); + Options = Options.substr(strlen(ADB_BACKUP_OP) + 1, strlen(cmd)); + if (cmdcheck == ADB_BACKUP_OP) + return Backup_ADB_Command(Options); + else { + return Restore_ADB_Backup(); + } + } + + return true; +} + +bool twrpAdbBuFifo::start(void) { + LOGINFO("Starting Adb Backup FIFO\n"); + unlink(TW_ADB_FIFO); + if (mkfifo(TW_ADB_FIFO, 06660) != 0) { + LOGINFO("Unable to mkfifo %s\n", TW_ADB_FIFO); + return false; + } + adb_fifo_fd = open(TW_ADB_FIFO, O_RDONLY | O_NONBLOCK); + if (adb_fifo_fd < 0) { + LOGERR("Unable to open TW_ADB_FIFO for reading.\n"); + close(adb_fifo_fd); + return false; + } + while (true) { + Check_Adb_Fifo_For_Events(); + usleep(8000); + } + //Shouldn't get here but cleanup anwyay + close(adb_fifo_fd); + return true; +} + +pthread_t twrpAdbBuFifo::threadAdbBuFifo(void) { + pthread_t thread; + ThreadPtr adbfifo = &twrpAdbBuFifo::start; + PThreadPtr p = *(PThreadPtr*)&adbfifo; + pthread_create(&thread, NULL, p, this); + return thread; +} + +bool twrpAdbBuFifo::Backup_ADB_Command(std::string Options) { + std::vector args; + std::string Backup_List; + bool adbbackup = true, ret = false; + std::string rmopt = "--"; + + std::replace(Options.begin(), Options.end(), ':', ' '); + args = TWFunc::Split_String(Options, " "); + + DataManager::SetValue(TW_USE_COMPRESSION_VAR, 0); + DataManager::SetValue(TW_SKIP_DIGEST_GENERATE_VAR, 0); + + if (args[1].compare("--twrp") != 0) { + gui_err("twrp_adbbu_option=--twrp option is required to enable twrp adb backup"); + sleep(2); + return false; + } + + for (unsigned i = 2; i < args.size(); i++) { + int compress; + + std::string::size_type size = args[i].find(rmopt); + if (size != std::string::npos) + args[i].erase(size, rmopt.length()); + + if (args[i].compare("compress") == 0) { + gui_msg("compression_on=Compression is on"); + DataManager::SetValue(TW_USE_COMPRESSION_VAR, 1); + continue; + } + DataManager::GetValue(TW_USE_COMPRESSION_VAR, compress); + gui_print("%s\n", args[i].c_str()); + std::string path; + path = "/" + args[i]; + TWPartition* part = PartitionManager.Find_Partition_By_Path(path); + if (part) { + Backup_List += path; + Backup_List += ";"; + } + else { + gui_msg(Msg(msg::kError, "partition_not_found=path: {1} not found in partition list")(path)); + return false; + } + } + + if (Backup_List.empty()) { + DataManager::GetValue("tw_backup_list", Backup_List); + if (Backup_List.empty()) { + gui_err("no_partition_selected=No partitions selected for backup."); + return false; + } + } + else + DataManager::SetValue("tw_backup_list", Backup_List); + + DataManager::SetValue("tw_action", "clear"); + DataManager::SetValue("tw_action_text1", gui_lookup("running_recovery_commands", "Running Recovery Commands")); + DataManager::SetValue("tw_action_text2", ""); + gui_changePage("action_page"); + + ret = PartitionManager.Run_Backup(adbbackup); + DataManager::SetValue(TW_BACKUP_NAME, gui_lookup("auto_generate", "(Auto Generate)")); + if (!ret) { + gui_err("backup_fail=Backup failed"); + return false; + } + gui_msg("backup_complete=Backup Complete"); + DataManager::SetValue("ui_progress", 100); + sleep(2); //give time for user to see messages on console + gui_changePage("main"); + return true; +} + +bool twrpAdbBuFifo::Restore_ADB_Backup(void) { + int partition_count = 0; + std::string Restore_Name; + std::size_t pos = 0; + struct AdbBackupFileTrailer adbmd5; + struct PartitionSettings part_settings; + int adb_control_twrp_fd, adb_write_fd, systemro; + int adb_control_bu_fd, ret = 0; + char cmd[512]; + + part_settings.total_restore_size = 0; + + PartitionManager.Mount_All_Storage(); + DataManager::SetValue(TW_SKIP_DIGEST_CHECK_VAR, 0); + LOGINFO("opening TW_ADB_BU_CONTROL\n"); + adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + LOGINFO("opening TW_ADB_TWRP_CONTROL\n"); + adb_control_twrp_fd = open(TW_ADB_TWRP_CONTROL, O_RDONLY | O_NONBLOCK); + memset(&adbmd5, 0, sizeof(adbmd5)); + + DataManager::SetValue("tw_action", "clear"); + DataManager::SetValue("tw_action_text1", gui_lookup("running_recovery_commands", "Running Recovery Commands")); + DataManager::SetValue("tw_action_text2", ""); + gui_changePage("action_page"); + + while (1) { + memset(&cmd, 0, sizeof(cmd)); + if (read(adb_control_twrp_fd, cmd, sizeof(cmd)) > 0) { + struct AdbBackupControlType cmdstruct; + + memset(&cmdstruct, 0, sizeof(cmdstruct)); + memcpy(&cmdstruct, cmd, sizeof(cmdstruct)); + std::string cmdstr(cmdstruct.type); + std::string cmdtype = cmdstr.substr(0, sizeof(cmdstruct.type) - 1); + if (cmdtype == TWSTREAMHDR) { + struct AdbBackupStreamHeader twhdr; + memcpy(&twhdr, cmd, sizeof(cmd)); + LOGINFO("ADB Partition count: %" PRIu64 "\n", twhdr.partition_count); + LOGINFO("ADB version: %" PRIu64 "\n", twhdr.version); + if (twhdr.version != ADB_BACKUP_VERSION) { + LOGERR("Incompatible adb backup version!\n"); + break; + } + partition_count = twhdr.partition_count; + } + else if (cmdtype == MD5TRAILER) { + LOGINFO("Restoring MD5TRAILER\n"); + memcpy(&adbmd5, cmd, sizeof(cmd)); + } + else if (cmdtype == TWMD5) { + struct AdbBackupFileTrailer md5check; + LOGINFO("Restoring TWMD5\n"); + + memset(&md5check, 0, sizeof(md5check)); + memcpy(&md5check, cmd, sizeof(cmd)); + if (strcmp(md5check.md5, adbmd5.md5) != 0) { + LOGERR("md5 doesn't match!\n"); + LOGERR("file md5: %s\n", adbmd5.md5); + LOGERR("check md5: %s\n", md5check.md5); + ret = false; + break; + } + else { + LOGINFO("adbrestore md5 matches\n"); + LOGINFO("adbmd5.md5: %s\n", adbmd5.md5); + LOGINFO("md5check.md5: %s\n", md5check.md5); + } + } + else if (cmdtype == TWENDADB) { + LOGINFO("received TWENDADB\n"); + break; + } + else { + struct twfilehdr twimghdr; + memcpy(&twimghdr, cmd, sizeof(cmd)); + std::string cmdstr(twimghdr.type); + Restore_Name = twimghdr.name; + part_settings.total_restore_size = twimghdr.size; + if (cmdtype == TWIMG) { + LOGINFO("ADB Type: %s\n", twimghdr.type); + LOGINFO("ADB Restore_Name: %s\n", Restore_Name.c_str()); + LOGINFO("ADB Restore_size: %" PRIu64 "\n", part_settings.total_restore_size); + string compression = (twimghdr.compressed == 1) ? "compressed" : "uncompressed"; + LOGINFO("ADB compression: %s\n", compression.c_str()); + std::string Backup_FileName; + std::size_t pos = Restore_Name.find_last_of("/"); + std::string path = "/" + Restore_Name.substr(pos, Restore_Name.size()); + pos = path.find_first_of("."); + path = path.substr(0, pos); + if (path.substr(0,1).compare("//")) { + path = path.substr(1, path.size()); + } + + pos = Restore_Name.find_last_of("/"); + Backup_FileName = Restore_Name.substr(pos + 1, Restore_Name.size()); + part_settings.Part = PartitionManager.Find_Partition_By_Path(path); + part_settings.Backup_Folder = path; + PartitionManager.Set_Restore_Files(path); + part_settings.partition_count = partition_count; + part_settings.adbbackup = true; + part_settings.adb_compression = twimghdr.compressed; + part_settings.PM_Method = PM_RESTORE; + ProgressTracking progress(part_settings.total_restore_size); + part_settings.progress = &progress; + if (!PartitionManager.Restore_Partition(&part_settings)) { + LOGERR("ADB Restore failed.\n"); + return false; + } + } + else if (cmdtype == TWFN) { + LOGINFO("ADB Type: %s\n", twimghdr.type); + LOGINFO("ADB Restore_Name: %s\n", Restore_Name.c_str()); + LOGINFO("ADB Restore_size: %" PRIi64 "\n", part_settings.total_restore_size); + string compression = (twimghdr.compressed == 1) ? "compressed" : "uncompressed"; + LOGINFO("ADB compression: %s\n", compression.c_str()); + std::string Backup_FileName; + std::size_t pos = Restore_Name.find_last_of("/"); + std::string path = "/" + Restore_Name.substr(pos, Restore_Name.size()); + pos = path.find_first_of("."); + path = path.substr(0, pos); + if (path.substr(0,1).compare("//")) { + path = path.substr(1, path.size()); + } + + pos = Restore_Name.find_last_of("/"); + Backup_FileName = Restore_Name.substr(pos + 1, Restore_Name.size()); + pos = Restore_Name.find_last_of("/"); + part_settings.Part = PartitionManager.Find_Partition_By_Path(path); + part_settings.Part->Set_Backup_FileName(Backup_FileName); + PartitionManager.Set_Restore_Files(path); + + if (path.compare("/system") == 0) { + if (part_settings.Part->Is_Read_Only()) { + struct AdbBackupControlType twerror; + strncpy(twerror.start_of_header, TWRP, sizeof(twerror.start_of_header)); + strncpy(twerror.type, TWERROR, sizeof(twerror.type)); + memset(twerror.space, 0, sizeof(twerror.space)); + twerror.crc = crc32(0L, Z_NULL, 0); + twerror.crc = crc32(twerror.crc, (const unsigned char*) &twerror, sizeof(twerror)); + if (write(adb_control_bu_fd, &twerror, sizeof(twerror)) < 0) { + LOGERR("Cannot write to ADB_CONTROL_BU_FD: %s\n", strerror(errno)); + } + gui_msg(Msg(msg::kError, "restore_read_only=Cannot restore {1} -- mounted read only.")(part_settings.Part->Backup_Display_Name)); + return false; + + } + } + part_settings.partition_count = partition_count; + part_settings.adbbackup = true; + part_settings.adb_compression = twimghdr.compressed; + part_settings.total_restore_size += part_settings.Part->Get_Restore_Size(&part_settings); + part_settings.PM_Method = PM_RESTORE; + ProgressTracking progress(part_settings.total_restore_size); + part_settings.progress = &progress; + if (!PartitionManager.Restore_Partition(&part_settings)) { + LOGERR("ADB Restore failed.\n"); + return false; + } + } + } + } + } + gui_msg("restore_complete=Restore Complete"); + + if (!twadbbu::Write_TWENDADB()) + ret = false; + sleep(2); //give time for user to see messages on console + DataManager::SetValue("ui_progress", 100); + gui_changePage("main"); + return ret; +} diff --git a/twrpAdbBuFifo.hpp b/twrpAdbBuFifo.hpp new file mode 100644 index 000000000..e709b9671 --- /dev/null +++ b/twrpAdbBuFifo.hpp @@ -0,0 +1,40 @@ +/* + Copyright 2013 to 2017 TeamWin + This file is part of TWRP/TeamWin Recovery Project. + + TWRP is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + TWRP is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with TWRP. If not, see . +*/ + +#ifndef TWRPADBFIFO_HPP +#define TWRPADBFIFO_HPP + +#include +#include + +#define TW_ADB_FIFO "/tmp/twadbfifo" + +class twrpAdbBuFifo { + public: + twrpAdbBuFifo(void); + pthread_t threadAdbBuFifo(void); + private: + bool start(void); + bool Backup_ADB_Command(std::string Options); + bool Check_Adb_Fifo_For_Events(void); + bool Restore_ADB_Backup(void); + typedef bool (twrpAdbBuFifo::*ThreadPtr)(void); + typedef void* (*PThreadPtr)(void *); + int adb_fifo_fd; +}; +#endif -- cgit v1.2.3