{

FileHandleReleaser(FILE* fp){fp_ = fp;}

virtual ~FileHandleReleaser(){::fclose(fp_);}

FILE* fp_;

{

DIR* dir = opendir(_apk_patch_path);

if (dir == NULL){

MY_INFO("opendir failed:%d[%s]", errno, _apk_patch_path);

return;

}

struct dirent *ent = NULL;

while((ent = readdir(dir)) != NULL) {

if(ent->d_type & DT_REG) {

std::string patch_file = std::string(_apk_patch_path) + "/" + ent->d_name;

_files.push_back(patch_file);

MY_INFO("patch file:[%s]", patch_file.c_str());

}

}

closedir(dir);

{

off_t fileLength, seekStart;

long readAmount;

int i;

EndOfCentralDir endOfCentralDir;

FILE *fp = fopen(_path, "rb");

if (fp == NULL){

MY_ERROR("failure parse file %s", _path);

return -1;

}

FileHandleReleaser autoDel(fp);

fseek(fp, 0, SEEK_END);

fileLength = ftell(fp);

rewind(fp);

/* too small to be a ZIP archive? */

if (fileLength < EndOfCentralDir::kEOCDLen) {

MY_ERROR("%s len is too small\n", _path);

return -1;

}

unsigned char* buf = new unsigned char[EndOfCentralDir::kMaxEOCDSearch];

if (buf == NULL) {

MY_ERROR("failure allocating %d bytes", EndOfCentralDir::kMaxEOCDSearch);

return -1;

}

if (fileLength > EndOfCentralDir::kMaxEOCDSearch) {

seekStart = fileLength - EndOfCentralDir::kMaxEOCDSearch;

readAmount = EndOfCentralDir::kMaxEOCDSearch;

} else {

seekStart = 0;

readAmount = (long) fileLength;

}

if (fseek(fp, seekStart, SEEK_SET) != 0) {

MY_ERROR("failure seeking to end of zip at %ld", (long) seekStart);

delete[] buf;

return -1;

}

/* read the last part of the file into the buffer */

if (fread(buf, 1, readAmount, fp) != (size_t) readAmount) {

MY_ERROR("read error! wanted %ld\n", readAmount);

delete[] buf;

return -1;

}

/* find the end-of-central-dir magic */

for (i = readAmount - 4; i >= 0; i--) {

if (buf[i] == 0x50 && ZipEntry::getLongLE(&buf[i]) == EndOfCentralDir::kSignature) {

break;

}

}

if (i < 0) {

MY_ERROR("not zip:%s\n", _path);

delete[] buf;

return -1;

}

/* extract eocd values */

int result = endOfCentralDir.readBuf(buf + i, readAmount - i);

if (result != NO_ERROR) {

MY_ERROR("failure reading %ld bytes for end of centoral dir", readAmount - i);

delete[] buf;

return -1;

}

//endOfCentralDir.dump();

if (endOfCentralDir.mDiskNumber != 0 || endOfCentralDir.mDiskWithCentralDir != 0 ||

endOfCentralDir.mNumEntries != endOfCentralDir.mTotalNumEntries)

{

MY_ERROR("archive spanning not supported\n");

delete[] buf;

return -1;

}

/*

if (fseek(fp, endOfCentralDir.mCentralDirOffset, SEEK_SET) != 0) {

MY_ERROR("failure seeking to central dir offset %ld\n", endOfCentralDir.mCentralDirOffset);

delete[] buf;

return -1;

}

/*

int entry;

for (entry = 0; entry < endOfCentralDir.mTotalNumEntries; entry++) {

ZipEntry* pEntry = new ZipEntry;

result = pEntry->initFromCDE(fp);

if (result != NO_ERROR) {

MY_ERROR("initFromCDE failed\n");

delete pEntry;

delete[] buf;

return -1;

}

const char* filename = pEntry->getFileName();

int name_len = strlen(filename);

bool is_directory = name_len > 0 ? filename[name_len - 1] == '/' : true;

if (is_directory)

{

MY_METHOD("ignore directory:%s", filename);

delete pEntry;

continue;

}

_all_entries.push_back(pEntry);

}

/*

{

unsigned char checkBuf[4];

if (fread(checkBuf, 1, 4, fp) != 4) {

MY_ERROR("EOCD check read failed");

delete[] buf;

return -1;

}

if (ZipEntry::getLongLE(checkBuf) != EndOfCentralDir::kSignature) {

MY_ERROR("EOCD read check failed");

delete[] buf;

return -1;

}

}

delete[] buf;

MY_LOG("got %zu entries[%u] in file %s", _all_entries.size(), (unsigned)sizeof(ZipEntry), _path);

return 0;

{

std::vector<std::vector<ZipEntry*> >::iterator it = _entries_in_zip_file.begin();

for(; it != _entries_in_zip_file.end(); it++)

{

std::vector<ZipEntry*>& entries = *it;

for(int i = 0; i < entries.size(); i++) {

delete entries[i];

}

entries.clear();

}

_entries_in_zip_file.clear();

int& pre_file_index,

uint64_t& pre_file_stop,

uint64_t& pre_shadow_stop,

std::vector<FilePartitionInfo>& patch_partitions,

FILE* changed_entries_header_patch_file)

{

int file_index = entry->mUserData1;

uint64_t file_start = entry->getEntryBegin();

int padding = 0;

const char* filename = entry->getFileName();

int name_len = strlen(filename);

bool is_directory = name_len > 0 ? filename[name_len - 1] == '/' : true;

if (!entry->isCompressed() && !is_directory)

{

uint64_t shadow_zip_raw_file_offset = pre_shadow_stop + ZipEntry::LocalFileHeader::kLFHLen + entry->mLFH.mFileNameLength + entry->mLFH.mExtraFieldLength;

const uint alignment = 4;

padding = (alignment - (shadow_zip_raw_file_offset % alignment)) % alignment;

}

bool can_merge = (file_index == pre_file_index) && ( file_start == pre_file_stop ) && padding == 0;

pre_file_index = file_index;

pre_file_stop = entry->getEntryEnd();

int32_t entry_size = pre_file_stop - file_start;

if (can_merge)

{

FilePartitionInfo& partition = patch_partitions.back();

partition.shadow_stop_ += entry_size;

partition.stop_in_file_ += entry_size;

pre_shadow_stop += entry_size;

}

else if (padding != 0){

uint64_t raw_file_offset = entry->getFileOffset();

if (entry->addPadding(padding) != 0){

MY_ERROR("entry add padding failed:%s", entry->getFileName());

exit(-1);

}

int header_file_start = ::ftell(changed_entries_header_patch_file);

if (entry->mLFH.write(changed_entries_header_patch_file) != 0)

{

MY_ERROR("write entry local file header failed:%s", entry->getFileName());

exit(-1);

}

int header_file_stop = ::ftell(changed_entries_header_patch_file);

//local header changed

{

FilePartitionInfo partition(pre_shadow_stop, pre_shadow_stop + header_file_stop - header_file_start, 1, header_file_start, header_file_stop);

patch_partitions.push_back(partition);

pre_shadow_stop += header_file_stop - header_file_start;

}

MY_METHOD("padding %d for %s, header size:%d, file begin:0x%08zx", padding, entry->getFileName(), header_file_stop - header_file_start, (size_t)pre_shadow_stop);

{

FilePartitionInfo partition(pre_shadow_stop, pre_shadow_stop + pre_file_stop - raw_file_offset, file_index, raw_file_offset, pre_file_stop);

patch_partitions.push_back(partition);

pre_shadow_stop += pre_file_stop - raw_file_offset;

}

}

else{

FilePartitionInfo partition(pre_shadow_stop, pre_shadow_stop + entry_size, file_index, file_start, pre_file_stop);

patch_partitions.push_back(partition);

pre_shadow_stop += entry_size;

}

{

ShadowZip test;

FILE* fr = test.fopen();

char test_apk_path[512] = {0};

snprintf( test_apk_path, sizeof(test_apk_path), "%s/test.apk", _patch_dir );

FILE* fw = ::fopen( test_apk_path, "wb" );

char buffer[1024] = {0};

while(1)

{

int read_cnt = test.fread( buffer, 1, sizeof(buffer), fr );

if (read_cnt <= 0){break;}

int write_cnt = fwrite( buffer, 1, read_cnt, fw );

if (write_cnt != read_cnt )

{

MY_LOG("write error %d != %d", write_cnt, read_cnt);

break;

}

}

{

MY_LOG("copy end at %ld, %llu", ::ftell(fw), (unsigned long long)test.end_of_file_);

}

test.fclose(fr);

::fclose(fw);

{

global_data->patch_partitions_.clear();

global_data->all_files_.clear();

global_data->all_files_.push_back(_sys_apk_file);

global_data->end_of_file_ = 0;

char changed_entries_header_path[512] = {0};

snprintf( changed_entries_header_path, sizeof(changed_entries_header_path), "%s/.entries_header.data", _patch_dir );

global_data->all_files_.push_back(changed_entries_header_path);

FILE* changed_entries_header_patch_file = ::fopen(changed_entries_header_path, "wb");

FileHandleReleaser autoDel(changed_entries_header_patch_file);

//set before get files

int persist_file_count = global_data->all_files_.size();

//find all patch files

char apk_patch_path[512] = {0};

snprintf( apk_patch_path, sizeof(apk_patch_path), "%s/assets_bin_Data", _patch_dir );

get_files( apk_patch_path, global_data->all_files_ );

if( global_data->all_files_.size() <= persist_file_count ){

MY_INFO("no apk patches:[%s/assets_bin_Data]", _patch_dir);

return -1;

}

//find all entries in patches

std::vector<std::vector<ZipEntry*> > entries_in_zip_file(global_data->all_files_.size());

std::map<std::string, ZipEntry*> filename_2_entry;

for(int i = 2; i < global_data->all_files_.size(); i++) {

std::string& zip_path = global_data->all_files_[i];

std::vector<ZipEntry*> zip_entries;

int ret = parse_apk(zip_path.c_str(), zip_entries);

entries_in_zip_file[i] = zip_entries;

if (ret != 0){

MY_ERROR("parse file failed:%s", zip_path.c_str());

clean_file_entries_map(entries_in_zip_file);

return -1;

}

for(int j = 0; j < zip_entries.size(); j++)

{

ZipEntry* entry = zip_entries[j];

entry->mUserData1 = i;

std::string filename = entry->getFileName();

MY_LOG("find patch:%s in %s", filename.c_str(), zip_path.c_str());

if (filename_2_entry.find(filename) != filename_2_entry.end()) {

MY_ERROR("dup patch file failed:%s", filename.c_str());

clean_file_entries_map(entries_in_zip_file);

return -1;

}

filename_2_entry[filename] = entry;

}

}

// find all entries in apk

std::vector<ZipEntry*> apk_entries;

int ret = parse_apk(_sys_apk_file, apk_entries);

entries_in_zip_file[0] = apk_entries;

if (ret != 0){

MY_ERROR("parse file failed:%s", _sys_apk_file);

clean_file_entries_map(entries_in_zip_file);

return -1;

}

//entries partition

global_data->patch_partitions_.clear();

std::vector<ZipEntry*> all_entries;

int pre_file_index = -1;

uint64_t pre_file_stop = 0;

uint64_t pre_shadow_stop = 0;

for(int i = 0; i < apk_entries.size(); i++)

{

ZipEntry* entry = apk_entries[i];

std::string name(entry->getFileName());

std::map<std::string, ZipEntry*>::iterator it = filename_2_entry.find(name);

if (it != filename_2_entry.end()){ entry = it->second; }

entry->mUserData2 = 1;

uint64_t entry_new_start = pre_shadow_stop;

add_entry_to_partition(entry, pre_file_index, pre_file_stop, pre_shadow_stop, global_data->patch_partitions_, changed_entries_header_patch_file);

entry->setLFHOffset((off_t)entry_new_start);

all_entries.push_back(entry);

}

for(int i = 1; i < entries_in_zip_file.size(); i++)

{

std::vector<ZipEntry*>& entries = entries_in_zip_file[i];

for(int j = 0; j < entries.size(); j++) {

ZipEntry* entry = entries[j];

if (entry->mUserData2 != 0) continue;

uint64_t entry_new_start = pre_shadow_stop;

add_entry_to_partition(entry, pre_file_index, pre_file_stop, pre_shadow_stop, global_data->patch_partitions_, changed_entries_header_patch_file);

entry->setLFHOffset((off_t)entry_new_start);

all_entries.push_back(entry);

}

}

uint64_t cd_offset = pre_shadow_stop;

char end_patch_path[512] = {0};

snprintf( end_patch_path, sizeof(end_patch_path), "%s/.patch.data", _patch_dir );

global_data->all_files_.push_back(end_patch_path);

FILE* end_patch_file = ::fopen(end_patch_path, "wb");

for(int i = 0; i < all_entries.size(); i++) {

ZipEntry* entry = all_entries[i];

MY_LOG("mapping [%08lx-%08lx-%08lx-%08lx] %s, method:%d, ", entry->getEntryBegin(), entry->getFileOffset(), entry->getFileOffset() + entry->getCompressedLen(), entry->getEntryEnd(),

entry->getFileName(), entry->mCDE.mCompressionMethod);

entry->mCDE.write(end_patch_file);

}

EndOfCentralDir end_of_cd;

end_of_cd.mNumEntries = all_entries.size();

end_of_cd.mTotalNumEntries = all_entries.size();

end_of_cd.mCentralDirSize = ::ftell(end_patch_file);

end_of_cd.mCentralDirOffset = pre_shadow_stop;

end_of_cd.write( end_patch_file );

uint64_t end_size = ::ftell(end_patch_file);

::fclose(end_patch_file);

global_data->end_of_file_ = cd_offset + end_size;

FilePartitionInfo partition(cd_offset, global_data->end_of_file_, global_data->all_files_.size() - 1, 0, end_size);

global_data->patch_partitions_.push_back(partition);

log(global_data);

clean_file_entries_map(entries_in_zip_file);

return 0;

{

for(int i = 0; i < global_data->patch_partitions_.size(); i++)

{

FilePartitionInfo& partition = global_data->patch_partitions_[i];

MY_LOG("0x%08llx - 0x%08llx file:%lld, [0x%08llx - 0x%08llx] %s",

(unsigned long long)partition.shadow_start_,

(unsigned long long)partition.shadow_stop_,

(unsigned long long)partition.file_index_,

(unsigned long long)partition.start_in_file_,

(unsigned long long)partition.stop_in_file_,

global_data->all_files_[partition.file_index_].c_str());

}

MY_LOG("eof_pos 0x%08llx", (unsigned long long)global_data->end_of_file_);

{

MY_METHOD("get_eof_pos -> 0x%08llx", (unsigned long long)g_shadowzip_global_data->end_of_file_);

return g_shadowzip_global_data->end_of_file_;

{

bool ret = false;

std::vector<ZipEntry*> zip_entries;

if (parse_apk(_apk_file, zip_entries) != 0){

MY_ERROR("parse file failed:%s", _apk_file);

return ret;

}

for(int j = 0; j < zip_entries.size(); j++)

{

ZipEntry* entry = zip_entries[j];

std::string filename = entry->getFileName();

if (memcmp(filename.c_str(), _check_path, strlen(_check_path)) == 0){

ret = true;

break;

}

}

for(int i = 0; i < zip_entries.size(); i++) {

delete zip_entries[i];

}

zip_entries.clear();

MY_INFO("%s%s contains path:%s", _apk_file, ret ? "": " doesn't", _check_path);

return ret;

{

patch_partitions_ = g_shadowzip_global_data->patch_partitions_;

all_files_ = g_shadowzip_global_data->all_files_;

end_of_file_ = g_shadowzip_global_data->end_of_file_;

partition_step = std::max(1, (int)ceil(sqrt(patch_partitions_.size())));

{

PROFILER_TIMER("ShadowZip::fseek");

MY_METHOD("fseek -> 0x%08zx at 0x%08llx with type %d", (size_t)stream, (unsigned long long)offset, whence);

int64_t cur_pos = pos_;

if (whence == SEEK_SET){

pos_ = offset;

}

else if (whence == SEEK_CUR){

pos_ += offset;

}

else if (whence == SEEK_END){

pos_ = end_of_file_ + offset;

}

if (pos_ < 0 || pos_ > end_of_file_){

pos_ = cur_pos;

MY_ERROR("fseek failed: pos:0x%08llx, end_of_file:0x%08llx", (unsigned long long)pos_, (unsigned long long)end_of_file_);

return -1;

}

return 0;

{

MY_METHOD("ftell -> 0x%08zx at 0x%08llx", (size_t)stream, (unsigned long long)pos_);

return (long) pos_;

{

int count = patch_partitions_.size();

int step = partition_step;

int last_i = 0;

for (int i = 0; i < count; i += step)

{

const FilePartitionInfo& info = patch_partitions_[i];

if (begin >= info.shadow_stop_){

last_i = i;

continue;

}

break;

}

return last_i;

{

PROFILER_TIMER("ShadowZip::fread");

MY_METHOD("fread -> 0x%08zx at 0x%08llx, size:%zu, n:%zu", (size_t)stream, (unsigned long long)pos_, size, nmemb);

if (((int)nmemb) <= 0){return 0;}

uint64_t begin = pos_;

uint64_t end = pos_ + size * nmemb;

size_t ret = 0;

int start_i = fast_find_partition(begin);

int count = patch_partitions_.size();

void* write_ptr = ptr;

for(int i = start_i; i < count; i++)

{

FilePartitionInfo& info = patch_partitions_[i];

if (begin >= info.shadow_stop_){

continue;

}

assert(begin >= info.shadow_start_);

uint64_t start_in_file = begin - info.shadow_start_ + info.start_in_file_;

uint64_t stop_in_file = (end >= info.shadow_stop_) ? info.stop_in_file_ : (end - info.shadow_start_ + info.start_in_file_);

int64_t read_size = stop_in_file - start_in_file;

if (read_size > nmemb){

MY_LOG("p:%d, start:[%zx,%zx) read size:%zu", i, (size_t)start_in_file, (size_t)stop_in_file, (size_t)read_size);

MY_LOG("shadow:[%zx,%zx) pos:%zx", (size_t)begin, (size_t)end, (size_t)pos_);

}

FILE* fp = prepare_file(info.file_index_);

assert(fp != NULL);

{

PROFILER_TIMER("ShadowZip::fseek & fread");

::fseek(fp, start_in_file, SEEK_SET);

::fread(write_ptr, 1, read_size, fp);

}

ret += read_size;

pos_ += read_size;

write_ptr = (char*)write_ptr + read_size;

begin += read_size;

if (begin >= end){return ret;}

}

return ret;

{

MY_METHOD("fclose -> 0x%08zx at 0x%08llx", (size_t)stream, (unsigned long long)pos_);

for(int i = 0; i < fp_array_.size(); i++)

{

FILE* fp = fp_array_[i];

if (fp) {

MY_METHOD("fclose -> 0x%08zx fp%d at 0x%08lx", (size_t)stream, i, ::ftell(fp));

::fclose(fp);

--g_total_file_handlers;

}

}

fp_array_.clear();

return 0;