535 строки
17 KiB
C++
535 строки
17 KiB
C++
// Copyright 2014 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// rezip is a tool which is used to modify zip files. It reads in a
|
|
// zip file and outputs a new zip file after applying various
|
|
// transforms. The tool is used in the Android Chromium build process
|
|
// to modify an APK file (which are zip files). The main application
|
|
// of this is to modify the APK so that the shared library is no
|
|
// longer compressed. Ironically, this saves both transmission and
|
|
// device drive space. It saves transmission space because
|
|
// uncompressed libraries make much smaller deltas with previous
|
|
// versions. It saves device drive space because it is no longer
|
|
// necessary to have both a compressed and uncompressed shared library
|
|
// on the device. To achieve this the uncompressed library is opened
|
|
// directly from within the APK using the "crazy" linker.
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
#include "third_party/zlib/contrib/minizip/unzip.h"
|
|
#include "third_party/zlib/contrib/minizip/zip.h"
|
|
|
|
const int kMaxFilenameInZip = 256;
|
|
const int kMaxExtraFieldInZip = 8192;
|
|
const int kBufferSize = 4096;
|
|
// Note do not use sysconf(_SC_PAGESIZE) here as that will give you the
|
|
// page size of the host, this should be the page size of the target.
|
|
const int kPageSizeOnDevice = 4096;
|
|
|
|
// This is done to avoid having to make a dependency on all of base.
|
|
class LogStream {
|
|
public:
|
|
~LogStream() {
|
|
stream_.flush();
|
|
std::cerr << stream_.str() << std::endl;
|
|
}
|
|
std::ostream& stream() {
|
|
return stream_;
|
|
}
|
|
private:
|
|
std::ostringstream stream_;
|
|
};
|
|
|
|
#define LOG(tag) (LogStream().stream() << #tag << ":")
|
|
|
|
// Copy the data from the currently opened file in the zipfile we are unzipping
|
|
// into the currently opened file of the zipfile we are zipping.
|
|
static bool CopySubfile(unzFile in_file,
|
|
zipFile out_file,
|
|
const char* in_zip_filename,
|
|
const char* out_zip_filename,
|
|
const char* in_filename,
|
|
const char* out_filename) {
|
|
char buf[kBufferSize];
|
|
|
|
int bytes = 0;
|
|
while (true) {
|
|
bytes = unzReadCurrentFile(in_file, buf, sizeof(buf));
|
|
if (bytes < 0) {
|
|
LOG(ERROR) << "failed to read from " << in_filename << " in zipfile "
|
|
<< in_zip_filename;
|
|
return false;
|
|
}
|
|
|
|
if (bytes == 0) {
|
|
break;
|
|
}
|
|
|
|
if (ZIP_OK != zipWriteInFileInZip(out_file, buf, bytes)) {
|
|
LOG(ERROR) << "failed to write from " << out_filename << " in zipfile "
|
|
<< out_zip_filename;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static zip_fileinfo BuildOutInfo(const unz_file_info& in_info) {
|
|
zip_fileinfo out_info;
|
|
out_info.tmz_date.tm_sec = in_info.tmu_date.tm_sec;
|
|
out_info.tmz_date.tm_min = in_info.tmu_date.tm_min;
|
|
out_info.tmz_date.tm_hour = in_info.tmu_date.tm_hour;
|
|
out_info.tmz_date.tm_mday = in_info.tmu_date.tm_mday;
|
|
out_info.tmz_date.tm_mon = in_info.tmu_date.tm_mon;
|
|
out_info.tmz_date.tm_year = in_info.tmu_date.tm_year;
|
|
|
|
out_info.dosDate = in_info.dosDate;
|
|
out_info.internal_fa = in_info.internal_fa;
|
|
out_info.external_fa = in_info.external_fa;
|
|
return out_info;
|
|
}
|
|
|
|
// RAII pattern for closing the unzip file.
|
|
class ScopedUnzip {
|
|
public:
|
|
ScopedUnzip(const char* z_filename)
|
|
: z_file_(NULL), z_filename_(z_filename) {}
|
|
|
|
unzFile OpenOrDie() {
|
|
z_file_ = unzOpen(z_filename_);
|
|
if (z_file_ == NULL) {
|
|
LOG(ERROR) << "failed to open zipfile " << z_filename_;
|
|
exit(1);
|
|
}
|
|
return z_file_;
|
|
}
|
|
|
|
~ScopedUnzip() {
|
|
if (z_file_ != NULL && unzClose(z_file_) != UNZ_OK) {
|
|
LOG(ERROR) << "failed to close input zipfile " << z_filename_;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
private:
|
|
const char* z_filename_;
|
|
unzFile z_file_;
|
|
};
|
|
|
|
// RAII pattern for closing the out zip file.
|
|
class ScopedZip {
|
|
public:
|
|
ScopedZip(const char* z_filename)
|
|
: z_file_(NULL), z_filename_(z_filename) {}
|
|
|
|
zipFile OpenOrDie() {
|
|
z_file_ = zipOpen(z_filename_, APPEND_STATUS_CREATE);
|
|
if (z_file_ == NULL) {
|
|
LOG(ERROR) << "failed to open zipfile " << z_filename_;
|
|
exit(1);
|
|
}
|
|
return z_file_;
|
|
}
|
|
|
|
~ScopedZip() {
|
|
if (z_file_ != NULL && zipClose(z_file_, NULL) != ZIP_OK) {
|
|
LOG(ERROR) << "failed to close output zipfile" << z_filename_;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
private:
|
|
const char* z_filename_;
|
|
zipFile z_file_;
|
|
};
|
|
|
|
typedef std::string (*RenameFun)(const char* in_filename);
|
|
typedef int (*AlignFun)(const char* in_filename,
|
|
unzFile in_file,
|
|
char* extra_buffer,
|
|
int size);
|
|
typedef bool (*InflatePredicateFun)(const char* filename);
|
|
|
|
static bool IsPrefixLibraryFilename(const char* filename,
|
|
const char* base_prefix) {
|
|
// We are basically matching "lib/[^/]*/<base_prefix>lib.*[.]so".
|
|
// However, we don't have C++11 regex, so we just handroll the test.
|
|
// Also we exclude "libchromium_android_linker.so" as a match.
|
|
const std::string filename_str = filename;
|
|
const std::string prefix = "lib/";
|
|
const std::string suffix = ".so";
|
|
|
|
if (filename_str.length() < suffix.length() + prefix.length()) {
|
|
// too short
|
|
return false;
|
|
}
|
|
|
|
if (filename_str.compare(0, prefix.size(), prefix) != 0) {
|
|
// does not start with "lib/"
|
|
return false;
|
|
}
|
|
|
|
if (filename_str.compare(filename_str.length() - suffix.length(),
|
|
suffix.length(),
|
|
suffix) != 0) {
|
|
// does not end with ".so"
|
|
return false;
|
|
}
|
|
|
|
const size_t last_slash = filename_str.find_last_of('/');
|
|
if (last_slash < prefix.length()) {
|
|
// Only one slash
|
|
return false;
|
|
}
|
|
|
|
const size_t second_slash = filename_str.find_first_of('/', prefix.length());
|
|
if (second_slash != last_slash) {
|
|
// filename_str contains more than two slashes.
|
|
return false;
|
|
}
|
|
|
|
const std::string libprefix = std::string(base_prefix) + "lib";
|
|
if (filename_str.compare(last_slash + 1, libprefix.length(), libprefix) !=
|
|
0) {
|
|
// basename piece does not start with <base_prefix>"lib"
|
|
return false;
|
|
}
|
|
|
|
const std::string linker = "libchromium_android_linker.so";
|
|
if (last_slash + 1 + linker.length() == filename_str.length() &&
|
|
filename_str.compare(last_slash + 1, linker.length(), linker) == 0) {
|
|
// Do not match the linker.
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool IsLibraryFilename(const char* filename) {
|
|
return IsPrefixLibraryFilename(filename, "");
|
|
}
|
|
|
|
static bool IsCrazyLibraryFilename(const char* filename) {
|
|
return IsPrefixLibraryFilename(filename, "crazy.");
|
|
}
|
|
|
|
static std::string RenameLibraryForCrazyLinker(const char* in_filename) {
|
|
if (!IsLibraryFilename(in_filename)) {
|
|
// Don't rename
|
|
return in_filename;
|
|
}
|
|
|
|
std::string filename_str = in_filename;
|
|
size_t last_slash = filename_str.find_last_of('/');
|
|
if (last_slash == std::string::npos ||
|
|
last_slash == filename_str.length() - 1) {
|
|
return in_filename;
|
|
}
|
|
|
|
// We rename the library, so that the Android Package Manager
|
|
// no longer extracts the library.
|
|
const std::string basename_prefix = "crazy.";
|
|
return filename_str.substr(0, last_slash + 1) + basename_prefix +
|
|
filename_str.substr(last_slash + 1);
|
|
}
|
|
|
|
// For any file which matches the crazy library pattern "lib/../crazy.lib*.so"
|
|
// add sufficient padding to the header that the start of the file will be
|
|
// page aligned on the target device.
|
|
static int PageAlignCrazyLibrary(const char* in_filename,
|
|
unzFile in_file,
|
|
char* extra_buffer,
|
|
int extra_size) {
|
|
if (!IsCrazyLibraryFilename(in_filename)) {
|
|
return extra_size;
|
|
}
|
|
const ZPOS64_T pos = unzGetCurrentFileZStreamPos64(in_file);
|
|
const int padding = kPageSizeOnDevice - (pos % kPageSizeOnDevice);
|
|
if (padding == kPageSizeOnDevice) {
|
|
return extra_size;
|
|
}
|
|
|
|
assert(extra_size < kMaxExtraFieldInZip - padding);
|
|
memset(extra_buffer + extra_size, 0, padding);
|
|
return extra_size + padding;
|
|
}
|
|
|
|
// As only the read side API provides offsets, we check that we added the
|
|
// correct amount of padding by reading the zip file we just generated.
|
|
// Also enforce that only one library is in the APK.
|
|
static bool CheckPageAlignAndOnlyOneLibrary(const char* out_zip_filename) {
|
|
ScopedUnzip scoped_unzip(out_zip_filename);
|
|
unzFile in_file = scoped_unzip.OpenOrDie();
|
|
|
|
int err = 0;
|
|
int count = 0;
|
|
bool checked = false;
|
|
while (true) {
|
|
char in_filename[kMaxFilenameInZip + 1];
|
|
// Get info and extra field for current file.
|
|
unz_file_info in_info;
|
|
err = unzGetCurrentFileInfo(in_file,
|
|
&in_info,
|
|
in_filename,
|
|
sizeof(in_filename) - 1,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0);
|
|
if (err != UNZ_OK) {
|
|
LOG(ERROR) << "failed to get filename" << out_zip_filename;
|
|
return false;
|
|
}
|
|
assert(in_info.size_filename <= kMaxFilenameInZip);
|
|
in_filename[in_info.size_filename] = '\0';
|
|
|
|
if (IsCrazyLibraryFilename(in_filename)) {
|
|
count++;
|
|
if (count > 1) {
|
|
LOG(ERROR)
|
|
<< "Found more than one library in " << out_zip_filename << "\n"
|
|
<< "Multiple libraries are not supported for APKs that use "
|
|
<< "'load_library_from_zip_file'.\n"
|
|
<< "See crbug/388223.\n"
|
|
<< "Note, check that your build is clean.\n"
|
|
<< "An unclean build can incorrectly incorporate old "
|
|
<< "libraries in the APK.";
|
|
return false;
|
|
}
|
|
err = unzOpenCurrentFile(in_file);
|
|
if (err != UNZ_OK) {
|
|
LOG(ERROR) << "failed to open subfile" << out_zip_filename << " "
|
|
<< in_filename;
|
|
return false;
|
|
}
|
|
|
|
const ZPOS64_T pos = unzGetCurrentFileZStreamPos64(in_file);
|
|
const int alignment = pos % kPageSizeOnDevice;
|
|
checked = (alignment == 0);
|
|
if (!checked) {
|
|
LOG(ERROR) << "Failed to page align library " << in_filename
|
|
<< ", position " << pos << " alignment " << alignment;
|
|
}
|
|
|
|
err = unzCloseCurrentFile(in_file);
|
|
if (err != UNZ_OK) {
|
|
LOG(ERROR) << "failed to close subfile" << out_zip_filename << " "
|
|
<< in_filename;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const int next = unzGoToNextFile(in_file);
|
|
if (next == UNZ_END_OF_LIST_OF_FILE) {
|
|
break;
|
|
}
|
|
if (next != UNZ_OK) {
|
|
LOG(ERROR) << "failed to go to next file" << out_zip_filename;
|
|
return false;
|
|
}
|
|
}
|
|
return checked;
|
|
}
|
|
|
|
// Copy files from one archive to another applying alignment, rename and
|
|
// inflate transformations if given.
|
|
static bool Rezip(const char* in_zip_filename,
|
|
const char* out_zip_filename,
|
|
AlignFun align_fun,
|
|
RenameFun rename_fun,
|
|
InflatePredicateFun inflate_predicate_fun) {
|
|
ScopedUnzip scoped_unzip(in_zip_filename);
|
|
unzFile in_file = scoped_unzip.OpenOrDie();
|
|
|
|
ScopedZip scoped_zip(out_zip_filename);
|
|
zipFile out_file = scoped_zip.OpenOrDie();
|
|
if (unzGoToFirstFile(in_file) != UNZ_OK) {
|
|
LOG(ERROR) << "failed to go to first file in " << in_zip_filename;
|
|
return false;
|
|
}
|
|
|
|
int err = 0;
|
|
while (true) {
|
|
char in_filename[kMaxFilenameInZip + 1];
|
|
// Get info and extra field for current file.
|
|
char extra_buffer[kMaxExtraFieldInZip];
|
|
unz_file_info in_info;
|
|
err = unzGetCurrentFileInfo(in_file,
|
|
&in_info,
|
|
in_filename,
|
|
sizeof(in_filename) - 1,
|
|
&extra_buffer,
|
|
sizeof(extra_buffer),
|
|
NULL,
|
|
0);
|
|
if (err != UNZ_OK) {
|
|
LOG(ERROR) << "failed to get filename " << in_zip_filename;
|
|
return false;
|
|
}
|
|
assert(in_info.size_filename <= kMaxFilenameInZip);
|
|
in_filename[in_info.size_filename] = '\0';
|
|
|
|
std::string out_filename = in_filename;
|
|
if (rename_fun != NULL) {
|
|
out_filename = rename_fun(in_filename);
|
|
}
|
|
|
|
bool inflate = false;
|
|
if (inflate_predicate_fun != NULL) {
|
|
inflate = inflate_predicate_fun(in_filename);
|
|
}
|
|
|
|
// Open the current file.
|
|
int method = 0;
|
|
int level = 0;
|
|
int raw = !inflate;
|
|
err = unzOpenCurrentFile2(in_file, &method, &level, raw);
|
|
if (inflate) {
|
|
method = Z_NO_COMPRESSION;
|
|
level = 0;
|
|
}
|
|
|
|
if (err != UNZ_OK) {
|
|
LOG(ERROR) << "failed to open subfile " << in_zip_filename << " "
|
|
<< in_filename;
|
|
return false;
|
|
}
|
|
|
|
// Get the extra field from the local header.
|
|
char local_extra_buffer[kMaxExtraFieldInZip];
|
|
int local_extra_size = unzGetLocalExtrafield(
|
|
in_file, &local_extra_buffer, sizeof(local_extra_buffer));
|
|
|
|
if (align_fun != NULL) {
|
|
local_extra_size =
|
|
align_fun(in_filename, in_file, local_extra_buffer, local_extra_size);
|
|
}
|
|
|
|
const char* local_extra = local_extra_size > 0 ? local_extra_buffer : NULL;
|
|
const char* extra = in_info.size_file_extra > 0 ? extra_buffer : NULL;
|
|
|
|
// Build the output info structure from the input info structure.
|
|
const zip_fileinfo out_info = BuildOutInfo(in_info);
|
|
|
|
const int ret = zipOpenNewFileInZip4(out_file,
|
|
out_filename.c_str(),
|
|
&out_info,
|
|
local_extra,
|
|
local_extra_size,
|
|
extra,
|
|
in_info.size_file_extra,
|
|
/* comment */ NULL,
|
|
method,
|
|
level,
|
|
/* raw */ 1,
|
|
/* windowBits */ 0,
|
|
/* memLevel */ 0,
|
|
/* strategy */ 0,
|
|
/* password */ NULL,
|
|
/* crcForCrypting */ 0,
|
|
in_info.version,
|
|
/* flagBase */ 0);
|
|
|
|
if (ZIP_OK != ret) {
|
|
LOG(ERROR) << "failed to open subfile " << out_zip_filename << " "
|
|
<< out_filename;
|
|
return false;
|
|
}
|
|
|
|
if (!CopySubfile(in_file,
|
|
out_file,
|
|
in_zip_filename,
|
|
out_zip_filename,
|
|
in_filename,
|
|
out_filename.c_str())) {
|
|
return false;
|
|
}
|
|
|
|
if (ZIP_OK != zipCloseFileInZipRaw(
|
|
out_file, in_info.uncompressed_size, in_info.crc)) {
|
|
LOG(ERROR) << "failed to close subfile " << out_zip_filename << " "
|
|
<< out_filename;
|
|
return false;
|
|
}
|
|
|
|
err = unzCloseCurrentFile(in_file);
|
|
if (err != UNZ_OK) {
|
|
LOG(ERROR) << "failed to close subfile " << in_zip_filename << " "
|
|
<< in_filename;
|
|
return false;
|
|
}
|
|
const int next = unzGoToNextFile(in_file);
|
|
if (next == UNZ_END_OF_LIST_OF_FILE) {
|
|
break;
|
|
}
|
|
if (next != UNZ_OK) {
|
|
LOG(ERROR) << "failed to go to next file" << in_zip_filename;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int main(int argc, const char* argv[]) {
|
|
if (argc != 4) {
|
|
LOG(ERROR) << "Usage: <action> <in_zipfile> <out_zipfile>";
|
|
LOG(ERROR) << " <action> is 'inflatealign', 'dropdescriptors' or 'rename'";
|
|
LOG(ERROR) << " 'inflatealign'";
|
|
LOG(ERROR) << " inflate and page aligns files of the form "
|
|
"lib/*/crazy.lib*.so";
|
|
LOG(ERROR) << " 'dropdescriptors':";
|
|
LOG(ERROR) << " remove zip data descriptors from the zip file";
|
|
LOG(ERROR) << " 'rename':";
|
|
LOG(ERROR) << " renames files of the form lib/*/lib*.so to "
|
|
"lib/*/crazy.lib*.so. Note libchromium_android_linker.so is "
|
|
"not renamed as the crazy linker can not load itself.";
|
|
exit(1);
|
|
}
|
|
|
|
const char* action = argv[1];
|
|
const char* in_zip_filename = argv[2];
|
|
const char* out_zip_filename = argv[3];
|
|
|
|
InflatePredicateFun inflate_predicate_fun = NULL;
|
|
AlignFun align_fun = NULL;
|
|
RenameFun rename_fun = NULL;
|
|
bool check_page_align = false;
|
|
if (strcmp("inflatealign", action) == 0) {
|
|
inflate_predicate_fun = &IsCrazyLibraryFilename;
|
|
align_fun = &PageAlignCrazyLibrary;
|
|
check_page_align = true;
|
|
} else if (strcmp("rename", action) == 0) {
|
|
rename_fun = &RenameLibraryForCrazyLinker;
|
|
} else if (strcmp("dropdescriptors", action) == 0) {
|
|
// Minizip does not know about data descriptors, so the default
|
|
// copying action will drop the descriptors. This should be fine
|
|
// as data descriptors are redundant information.
|
|
// Note we need to explicitly drop the descriptors before trying to
|
|
// do alignment otherwise we will miscalculate the position because
|
|
// we don't know about the data descriptors.
|
|
} else {
|
|
LOG(ERROR) << "Usage: <action> should be 'inflatealign', "
|
|
"'dropdescriptors' or 'rename'";
|
|
exit(1);
|
|
}
|
|
|
|
if (!Rezip(in_zip_filename,
|
|
out_zip_filename,
|
|
align_fun,
|
|
rename_fun,
|
|
inflate_predicate_fun)) {
|
|
exit(1);
|
|
}
|
|
if (check_page_align && !CheckPageAlignAndOnlyOneLibrary(out_zip_filename)) {
|
|
exit(1);
|
|
}
|
|
return 0;
|
|
}
|