diff options
Diffstat (limited to '')
| -rw-r--r-- | adbbu/libtwadbbu.cpp | 196 |
1 files changed, 196 insertions, 0 deletions
diff --git a/adbbu/libtwadbbu.cpp b/adbbu/libtwadbbu.cpp new file mode 100644 index 000000000..cdc2170ba --- /dev/null +++ b/adbbu/libtwadbbu.cpp @@ -0,0 +1,196 @@ +/* + Copyright 2013 to 2016 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 <zlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/select.h> +#include <sys/time.h> +#include <string> +#include <fstream> +#include <sstream> + +#include "twadbstream.h" +#include "libtwadbbu.hpp" + +bool twadbbu::Write_ADB_Stream_Header(uint64_t partition_count) { + struct AdbBackupStreamHeader twhdr; + int adb_control_bu_fd; + + 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"); + return false; + } + + strncpy(twhdr.start_of_header, TWRP, sizeof(twhdr.start_of_header)); + strncpy(twhdr.type, TWSTREAMHDR, sizeof(twhdr.type)); + twhdr.partition_count = partition_count; + twhdr.version = ADB_BACKUP_VERSION; + memset(twhdr.space, 0, sizeof(twhdr.space)); + 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"); + close(adb_control_bu_fd); + return false; + } + return true; +} + +bool twadbbu::Write_ADB_Stream_Trailer() { + int adb_control_bu_fd; + struct AdbBackupControlType endadb; + + memset(&endadb, 0, sizeof(endadb)); + + 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"); + return false; + } + strncpy(endadb.start_of_header, TWRP, sizeof(endadb.start_of_header)); + strncpy(endadb.type, TWENDADB, sizeof(endadb.type)); + 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"); + close(adb_control_bu_fd); + return false; + } + close(adb_control_bu_fd); + return true; +} + +bool twadbbu::Write_TWFN(std::string Backup_FileName, uint64_t file_size, bool use_compression) { + int adb_control_bu_fd; + adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + struct twfilehdr twfilehdr; + strncpy(twfilehdr.start_of_header, TWRP, sizeof(twfilehdr.start_of_header)); + strncpy(twfilehdr.type, TWFN, sizeof(twfilehdr.type)); + strncpy(twfilehdr.name, Backup_FileName.c_str(), sizeof(twfilehdr.name)); + twfilehdr.size = (file_size == 0 ? 1024 : file_size); + twfilehdr.compressed = use_compression; + twfilehdr.crc = crc32(0L, Z_NULL, 0); + twfilehdr.crc = crc32(twfilehdr.crc, (const unsigned char*) &twfilehdr, sizeof(twfilehdr)); + + 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"); + close(adb_control_bu_fd); + return false; + } + close(adb_control_bu_fd); + return true; +} + +bool twadbbu::Write_TWIMG(std::string Backup_FileName, uint64_t file_size) { + int adb_control_bu_fd; + struct twfilehdr twimghdr; + + adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + strncpy(twimghdr.start_of_header, TWRP, sizeof(twimghdr.start_of_header)); + strncpy(twimghdr.type, TWIMG, sizeof(twimghdr.type)); + twimghdr.size = file_size; + strncpy(twimghdr.name, Backup_FileName.c_str(), sizeof(twimghdr.name)); + twimghdr.crc = crc32(0L, Z_NULL, 0); + 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"); + return false; + } + + return true; +} + +bool twadbbu::Write_TWEOF() { + struct AdbBackupControlType tweof; + int adb_control_bu_fd; + int errctr = 0; + + printf("opening TW_ADB_BU_CONTROL\n"); + adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + while (adb_control_bu_fd < 0) { + printf("failed to open TW_ADB_BU_CONTROL. Retrying: %s\n", strerror(errno)); + adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + usleep(10000); + errctr++; + if (errctr > ADB_BU_MAX_ERROR) { + printf("Cannot write to adb_control_bu_fd: %s.\n", strerror(errno)); + close(adb_control_bu_fd); + return false; + } + } + memset(&tweof, 0, sizeof(tweof)); + strncpy(tweof.start_of_header, TWRP, sizeof(tweof.start_of_header)); + strncpy(tweof.type, TWEOF, sizeof(tweof.type)); + tweof.crc = crc32(0L, Z_NULL, 0); + tweof.crc = crc32(tweof.crc, (const unsigned char*) &tweof, sizeof(tweof)); + printf("Sending TWEOF to adb backup\n"); + if (write(adb_control_bu_fd, &tweof, sizeof(tweof)) < 0) { + printf("Cannot write to adb_control_bu_fd: %s.\n", strerror(errno)); + close(adb_control_bu_fd); + return false; + } + close(adb_control_bu_fd); + return true; +} + +bool twadbbu::Write_TWERROR() { + struct AdbBackupControlType twerror; + int adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + + 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) { + printf("Cannot write to adb control channel"); + return false; + } + close(adb_control_bu_fd); + return true; +} + +bool twadbbu::Write_TWENDADB() { + struct AdbBackupControlType endadb; + int adb_control_bu_fd = open(TW_ADB_BU_CONTROL, O_WRONLY | O_NONBLOCK); + + memset(&endadb, 0, sizeof(endadb)); + strncpy(endadb.start_of_header, TWRP, sizeof(endadb.start_of_header)); + strncpy(endadb.type, TWENDADB, sizeof(endadb.type)); + endadb.crc = crc32(0L, Z_NULL, 0); + endadb.crc = crc32(endadb.crc, (const unsigned char*) &endadb, sizeof(endadb)); + + printf("Sending TWENDADB to ADB Backup\n"); + if (write(adb_control_bu_fd, &endadb, sizeof(endadb)) < 1) { + printf("Cannot write to ADB_CONTROL_BU_FD: %s\n", strerror(errno)); + return false; + } + + close(adb_control_bu_fd); + return true; +} |