| /* |
| Copyright 2012 bigbiff/Dees_Troy 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 <http://www.gnu.org/licenses/>. |
| */ |
| |
| extern "C" { |
| #include "libtar/libtar.h" |
| } |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <fstream> |
| #include <fstream> |
| #include <iostream> |
| #include <string> |
| #include <dirent.h> |
| #include <sys/mman.h> |
| #include "twrpTar.hpp" |
| #include "common.h" |
| #include "data.hpp" |
| #include "variables.h" |
| #include <sstream> |
| #include "twrp-functions.hpp" |
| |
| using namespace std; |
| |
| int twrpTar::Generate_Multiple_Archives(string Path, string fn) { |
| DIR* d; |
| struct dirent* de; |
| struct stat st; |
| string FileName; |
| char actual_filename[255]; |
| |
| sprintf(actual_filename, fn.c_str(), Archive_File_Count); |
| |
| if (has_data_media == 1 && Path.size() >= 11 && strncmp(Path.c_str(), "/data/media", 11) == 0) |
| return 0; // Skip /data/media |
| LOGI("Path: '%s', archive filename: '%s'\n", Path.c_str(), actual_filename); |
| |
| d = opendir(Path.c_str()); |
| if (d == NULL) |
| { |
| LOGE("error opening '%s' -- error: %s\n", Path.c_str(), strerror(errno)); |
| closedir(d); |
| return -1; |
| } |
| while ((de = readdir(d)) != NULL) |
| { |
| FileName = Path + "/"; |
| FileName += de->d_name; |
| if (has_data_media == 1 && FileName.size() >= 11 && strncmp(FileName.c_str(), "/data/media", 11) == 0) |
| continue; // Skip /data/media |
| if (de->d_type == DT_DIR && strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..") != 0) |
| { |
| unsigned long long folder_size = TWFunc::Get_Folder_Size(FileName, false); |
| if (Archive_Current_Size + folder_size > MAX_ARCHIVE_SIZE) { |
| if (Generate_Multiple_Archives(FileName, fn) < 0) |
| return -1; |
| } else { |
| //FileName += "/"; |
| LOGI("Adding folder '%s'\n", FileName.c_str()); |
| if (tarDirs(FileName, actual_filename, true) < 0) |
| return -1; |
| Archive_Current_Size += folder_size; |
| } |
| } |
| else if (de->d_type == DT_REG || de->d_type == DT_LNK) |
| { |
| stat(FileName.c_str(), &st); |
| |
| if (Archive_Current_Size != 0 && Archive_Current_Size + st.st_size > MAX_ARCHIVE_SIZE) { |
| LOGI("Closing tar '%s', ", actual_filename); |
| closeTar(actual_filename, false); |
| Archive_File_Count++; |
| if (TWFunc::Get_File_Size(actual_filename) == 0) { |
| LOGE("Backup file size for '%s' is 0 bytes.\n", actual_filename); |
| return false; |
| } |
| if (Archive_File_Count > 999) { |
| LOGE("Archive count is too large!\n"); |
| return -1; |
| } |
| Archive_Current_Size = 0; |
| sprintf(actual_filename, fn.c_str(), Archive_File_Count); |
| LOGI("Creating tar '%s'\n", actual_filename); |
| ui_print("Creating archive %i...\n", Archive_File_Count + 1); |
| createTar(Path, actual_filename); |
| } |
| LOGI("Adding file: '%s'... ", FileName.c_str()); |
| if (addFile(FileName, true) < 0) |
| return -1; |
| Archive_Current_Size += st.st_size; |
| LOGI("added successfully, archive size: %llu\n", Archive_Current_Size); |
| if (st.st_size > 2147483648LL) |
| LOGE("There is a file that is larger than 2GB in the file system\n'%s'\nThis file may not restore properly\n", FileName.c_str()); |
| } |
| } |
| closedir(d); |
| return 0; |
| } |
| |
| int twrpTar::Split_Archive(string Path, string fn) |
| { |
| string temp = fn + "%03i"; |
| char actual_filename[255]; |
| |
| Archive_File_Count = 0; |
| Archive_Current_Size = 0; |
| sprintf(actual_filename, temp.c_str(), Archive_File_Count); |
| createTar(Path, actual_filename); |
| DataManager::GetValue(TW_HAS_DATA_MEDIA, has_data_media); |
| ui_print("Creating archive 1...\n"); |
| if (Generate_Multiple_Archives(Path, temp) < 0) { |
| LOGE("Error generating file list\n"); |
| return -1; |
| } |
| sprintf(actual_filename, temp.c_str(), Archive_File_Count); |
| closeTar(actual_filename, false); |
| LOGI("Done, created %i archives.\n", (Archive_File_Count++)); |
| return (Archive_File_Count); |
| } |
| |
| int twrpTar::extractTar(string rootdir, string fn) { |
| char* charRootDir = (char*) rootdir.c_str(); |
| bool gzip = false; |
| if (openTar(rootdir, fn, gzip) == -1) |
| return -1; |
| if (tar_extract_all(t, charRootDir) != 0) { |
| LOGE("Unable to extract tar archive '%s'\n", fn.c_str()); |
| return -1; |
| } |
| if (tar_close(t) != 0) { |
| LOGE("Unable to close tar file\n"); |
| return -1; |
| } |
| return 0; |
| } |
| |
| int twrpTar::extract(string rootdir, string fn) { |
| int len = 3; |
| char header[len]; |
| string::size_type i = 0; |
| int firstbyte = 0; |
| int secondbyte = 0; |
| int ret; |
| ifstream f; |
| f.open(fn.c_str(), ios::in | ios::binary); |
| f.get(header, len); |
| firstbyte = header[i] & 0xff; |
| secondbyte = header[++i] & 0xff; |
| f.close(); |
| if (firstbyte == 0x1f && secondbyte == 0x8b) { |
| //if you return the extractTGZ function directly, stack crashes happen |
| LOGI("Extracting gzipped tar\n"); |
| ret = extractTGZ(rootdir, fn); |
| return ret; |
| } |
| else { |
| LOGI("Extracting uncompressed tar\n"); |
| return extractTar(rootdir, fn); |
| } |
| } |
| |
| int twrpTar::tarDirs(string dir, string fn, bool include_root) { |
| DIR* d; |
| string mainfolder = dir + "/", subfolder; |
| char buf[1024]; |
| char* charTarFile = (char*) fn.c_str(); |
| d = opendir(dir.c_str()); |
| if (d != NULL) { |
| struct dirent* de; |
| while ((de = readdir(d)) != NULL) { |
| LOGI("adding %s\n", de->d_name); |
| #ifdef RECOVERY_SDCARD_ON_DATA |
| if ((dir == "/data" || dir == "/data/") && strcmp(de->d_name, "media") == 0) continue; |
| #endif |
| if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue; |
| |
| subfolder = mainfolder; |
| subfolder += de->d_name; |
| strcpy(buf, subfolder.c_str()); |
| if (de->d_type == DT_DIR) { |
| if (include_root) { |
| if (tar_append_tree(t, buf, NULL) != 0) { |
| LOGE("Error appending '%s' to tar archive '%s'\n", buf, charTarFile); |
| return -1; |
| } |
| } else { |
| string temp = Strip_Root_Dir(buf); |
| char* charTarPath = (char*) temp.c_str(); |
| if (tar_append_tree(t, buf, charTarPath) != 0) { |
| LOGE("Error appending '%s' to tar archive '%s'\n", buf, charTarFile); |
| return -1; |
| } |
| } |
| } else if (dir != "/" && (de->d_type == DT_REG || de->d_type == DT_LNK)) { |
| if (addFile(buf, include_root) != 0) |
| return -1; |
| } |
| fflush(NULL); |
| } |
| closedir(d); |
| } |
| return 0; |
| } |
| |
| int twrpTar::createTGZ(string dir, string fn) { |
| bool gzip = true; |
| if (createTar(dir, fn) == -1) |
| return -1; |
| if (tarDirs(dir, fn, false) == -1) |
| return -1; |
| if (closeTar(fn, gzip) == -1) |
| return -1; |
| return 0; |
| } |
| |
| int twrpTar::create(string dir, string fn) { |
| bool gzip = false; |
| if (createTar(dir, fn) == -1) |
| return -1; |
| if (tarDirs(dir, fn, false) == -1) |
| return -1; |
| if (closeTar(fn, gzip) == -1) |
| return -1; |
| return 0; |
| } |
| |
| int twrpTar::addFilesToExistingTar(vector <string> files, string fn) { |
| char* charTarFile = (char*) fn.c_str(); |
| |
| if (tar_open(&t, charTarFile, NULL, O_RDONLY | O_LARGEFILE, 0644, TAR_GNU) == -1) |
| return -1; |
| removeEOT(charTarFile); |
| if (tar_open(&t, charTarFile, NULL, O_WRONLY | O_APPEND | O_LARGEFILE, 0644, TAR_GNU) == -1) |
| return -1; |
| for (unsigned int i = 0; i < files.size(); ++i) { |
| char* file = (char*) files.at(i).c_str(); |
| if (tar_append_file(t, file, file) == -1) |
| return -1; |
| } |
| if (tar_append_eof(t) == -1) |
| return -1; |
| if (tar_close(t) == -1) |
| return -1; |
| return 0; |
| } |
| |
| int twrpTar::createTar(string rootdir, string fn) { |
| char* charTarFile = (char*) fn.c_str(); |
| char* charRootDir = (char*) rootdir.c_str(); |
| int use_compression = 0; |
| |
| DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression); |
| LOGI("2nd compression\n"); |
| if (use_compression) { |
| string cmd = "pigz - > '" + fn + "'"; |
| p = popen(cmd.c_str(), "w"); |
| fd = fileno(p); |
| if (!p) return -1; |
| if(tar_fdopen(&t, fd, charRootDir, NULL, O_RDONLY | O_LARGEFILE, 0644, TAR_GNU) != 0) { |
| pclose(p); |
| return -1; |
| } |
| } |
| else { |
| if (tar_open(&t, charTarFile, NULL, O_WRONLY | O_CREAT | O_LARGEFILE, 0644, TAR_GNU) == -1) |
| return -1; |
| } |
| return 0; |
| } |
| |
| int twrpTar::openTar(string rootdir, string fn, bool gzip) { |
| char* charRootDir = (char*) rootdir.c_str(); |
| char* charTarFile = (char*) fn.c_str(); |
| |
| if (gzip) { |
| LOGI("Opening as a gzip\n"); |
| string cmd = "pigz -d -c '" + fn + "'"; |
| FILE* pipe = popen(cmd.c_str(), "r"); |
| int fd = fileno(pipe); |
| if (!pipe) return -1; |
| if(tar_fdopen(&t, fd, charRootDir, NULL, O_RDONLY | O_LARGEFILE, 0644, TAR_GNU) != 0) { |
| LOGI("tar_fdopen returned error\n"); |
| pclose(pipe); |
| return -1; |
| } |
| } |
| else { |
| if (tar_open(&t, charTarFile, NULL, O_RDONLY | O_LARGEFILE, 0644, TAR_GNU) != 0) { |
| LOGE("Unable to open tar archive '%s'\n", charTarFile); |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| string twrpTar::Strip_Root_Dir(string Path) { |
| string temp; |
| size_t slash; |
| |
| if (Path.substr(0, 1) == "/") |
| temp = Path.substr(1, Path.size() - 1); |
| else |
| temp = Path; |
| slash = temp.find("/"); |
| if (slash == string::npos) |
| return temp; |
| else { |
| string stripped; |
| |
| stripped = temp.substr(slash, temp.size() - slash); |
| return stripped; |
| } |
| return temp; |
| } |
| |
| int twrpTar::addFile(string fn, bool include_root) { |
| char* charTarFile = (char*) fn.c_str(); |
| if (include_root) { |
| if (tar_append_file(t, charTarFile, NULL) == -1) |
| return -1; |
| } else { |
| string temp = Strip_Root_Dir(fn); |
| char* charTarPath = (char*) temp.c_str(); |
| if (tar_append_file(t, charTarFile, charTarPath) == -1) |
| return -1; |
| } |
| return 0; |
| } |
| |
| int twrpTar::closeTar(string fn, bool gzip) { |
| int use_compression; |
| DataManager::GetValue(TW_USE_COMPRESSION_VAR, use_compression); |
| |
| if (tar_append_eof(t) != 0) { |
| LOGE("tar_append_eof(): %s\n", strerror(errno)); |
| tar_close(t); |
| return -1; |
| } |
| if (tar_close(t) != 0) { |
| LOGE("Unable to close tar archive: '%s'\n", fn.c_str()); |
| return -1; |
| } |
| if (use_compression || gzip) { |
| LOGI("Closing popen and fd\n"); |
| pclose(p); |
| close(fd); |
| } |
| return 0; |
| } |
| |
| int twrpTar::removeEOT(string tarFile) { |
| char* charTarFile = (char*) tarFile.c_str(); |
| off_t tarFileEnd; |
| while (th_read(t) == 0) { |
| if (TH_ISREG(t)) |
| tar_skip_regfile(t); |
| tarFileEnd = lseek(t->fd, 0, SEEK_CUR); |
| } |
| if (tar_close(t) == -1) |
| return -1; |
| if (truncate(charTarFile, tarFileEnd) == -1) |
| return -1; |
| return 0; |
| } |
| |
| int twrpTar::compress(string fn) { |
| string cmd = "pigz " + fn; |
| p = popen(cmd.c_str(), "r"); |
| if (!p) return -1; |
| char buffer[128]; |
| string result = ""; |
| while(!feof(p)) { |
| if(fgets(buffer, 128, p) != NULL) |
| result += buffer; |
| } |
| pclose(p); |
| return 0; |
| } |
| |
| int twrpTar::extractTGZ(string rootdir, string fn) { |
| string splatrootdir(rootdir); |
| bool gzip = true; |
| char* splatCharRootDir = (char*) splatrootdir.c_str(); |
| if (openTar(rootdir, fn, gzip) == -1) |
| return -1; |
| int ret = tar_extract_all(t, splatCharRootDir); |
| if (tar_close(t) != 0) { |
| LOGE("Unable to close tar file\n"); |
| return -1; |
| } |
| return 0; |
| } |