{

std::vector<FilePartitionInfo> patch_partitions_;

std::vector<std::string> all_files_;

uint64_t end_of_file_;

{

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;

}

std::shared_ptr<FILE> autoDel(fp, [](FILE* fp){::fclose(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;

}

_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;

}

}

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)

{

int file_index = entry->mUserData1;

uint64_t file_start = entry->getEntryBegin();

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

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;

}

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 = old_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", old_ftell(fw), (unsigned long long)g_shadowzip_global_data->end_of_file_);

test.fclose(fr);

old_fclose(fw);

{

LeakSingleton<ShadowZipGlobalData, 0>::init();

old_fopen = NULL;

old_fseek = NULL;

old_ftell = NULL;

//old_rewind = NULL;

old_fread = NULL;

old_fgets = NULL;

old_fclose = NULL;

g_shadowzip_global_data->patch_partitions_.clear();

g_shadowzip_global_data->all_files_.clear();

g_shadowzip_global_data->all_files_.push_back(_sys_apk_file);

g_shadowzip_global_data->end_of_file_ = 0;

//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, g_shadowzip_global_data->all_files_ );

if( g_shadowzip_global_data->all_files_.size() <= 1 ){

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(g_shadowzip_global_data->all_files_.size());

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

for(int i = 1; i < g_shadowzip_global_data->all_files_.size(); i++) {

std::string& zip_path = g_shadowzip_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

g_shadowzip_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, g_shadowzip_global_data->patch_partitions_);

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, g_shadowzip_global_data->patch_partitions_);

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 );

g_shadowzip_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("%s, method:%d, LFHOffset:%08lx", entry->getFileName(), entry->mCDE.mCompressionMethod, entry->getLFHOffset());

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);

g_shadowzip_global_data->end_of_file_ = cd_offset + end_size;

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

g_shadowzip_global_data->patch_partitions_.push_back(partition);

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

{

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

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

(unsigned long long)partition.shadow_start_,

(unsigned long long)partition.shadow_stop_,

partition.file_index_,

(unsigned long long)partition.start_in_file_,

(unsigned long long)partition.stop_in_file_);

}

clean_file_entries_map(entries_in_zip_file);

return 0;

{

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_;

{

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_ = g_shadowzip_global_data->end_of_file_ + offset;

}

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

pos_ = cur_pos;

return -1;

}

return 0;

{

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

return (long) pos_;

{

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;

void* write_ptr = ptr;

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

{

FilePartitionInfo& info = g_shadowzip_global_data->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);

old_fseek(fp, start_in_file, SEEK_SET);

old_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, old_ftell(fp));

old_fclose(fp);

}

}

fp_array_.clear();

return 0;

{

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;