diff options
Diffstat (limited to 'adbbu')
| -rw-r--r-- | adbbu/Android.mk | 47 | ||||
| -rw-r--r-- | adbbu/adbbumain.cpp | 89 | ||||
| -rw-r--r-- | adbbu/libtwadbbu.cpp | 112 | ||||
| -rw-r--r-- | adbbu/libtwadbbu.hpp | 9 | ||||
| -rw-r--r-- | adbbu/twadbstream.h | 26 | ||||
| -rw-r--r-- | adbbu/twrpback.cpp | 158 | ||||
| -rw-r--r-- | adbbu/twrpback.hpp | 24 |
7 files changed, 322 insertions, 143 deletions
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 <http://www.gnu.org/licenses/>. +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <string.h> +#include <fcntl.h> +#include <errno.h> +#include <ctype.h> +#include <string> +#include <sstream> + +#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 <sys/select.h> #include <sys/time.h> #include <string> +#include <vector> #include <fstream> #include <sstream> #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<std::string> twadbbu::Get_ADB_Backup_Files(std::string fname) { + unsigned char buf[MAX_ADB_READ]; + struct AdbBackupControlType structcmd; + std::vector<std::string> 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<std::string>(); + } + + 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<std::string>(); + } + } + 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<std::string>(); + } + } + } + } + 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 <http://www.gnu.org/licenses/>. */ +#ifndef _LIBTWADBBU_HPP +#define _LIBTWADBBU_HPP #include <stdio.h> #include <stdlib.h> @@ -26,6 +28,7 @@ #include <sys/select.h> #include <sys/time.h> #include <string> +#include <vector> #include <fstream> #include <sstream> @@ -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<std::string> 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 <http://www.gnu.org/licenses/>. + You should have received a copy of the GNU General Public License + along with TWRP. If not, see <http://www.gnu.org/licenses/>. */ #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 <ctype.h> #include <semaphore.h> #include <string> -#include <fstream> #include <sstream> +#include <fstream> #include <algorithm> +#include <utils/threads.h> +#include <pthread.h> #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 <http://www.gnu.org/licenses/>. */ -#include <fstream> +#ifndef _TWRPBACK_HPP +#define _TWRPBACK_HPP -#include "../orscmd/orscmd.h" -#include "../variables.h" -#include "../twcommon.h" +#include <fstream> 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 |