| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "fastdeploy.h" |
| |
| #include <string.h> |
| #include <algorithm> |
| #include <array> |
| #include <memory> |
| |
| #include "android-base/file.h" |
| #include "android-base/strings.h" |
| #include "androidfw/ResourceTypes.h" |
| #include "androidfw/ZipFileRO.h" |
| #include "client/file_sync_client.h" |
| #include "commandline.h" |
| #include "fastdeploycallbacks.h" |
| #include "sysdeps.h" |
| |
| #include "adb_utils.h" |
| |
| static constexpr long kRequiredAgentVersion = 0x00000002; |
| |
| static constexpr const char* kDeviceAgentPath = "/data/local/tmp/"; |
| |
| static bool g_use_localagent = false; |
| |
| long get_agent_version() { |
| std::vector<char> versionOutputBuffer; |
| std::vector<char> versionErrorBuffer; |
| |
| int statusCode = capture_shell_command("/data/local/tmp/deployagent version", |
| &versionOutputBuffer, &versionErrorBuffer); |
| long version = -1; |
| |
| if (statusCode == 0 && versionOutputBuffer.size() > 0) { |
| version = strtol((char*)versionOutputBuffer.data(), NULL, 16); |
| } |
| |
| return version; |
| } |
| |
| int get_device_api_level() { |
| std::vector<char> sdkVersionOutputBuffer; |
| std::vector<char> sdkVersionErrorBuffer; |
| int api_level = -1; |
| |
| int statusCode = capture_shell_command("getprop ro.build.version.sdk", &sdkVersionOutputBuffer, |
| &sdkVersionErrorBuffer); |
| if (statusCode == 0 && sdkVersionOutputBuffer.size() > 0) { |
| api_level = strtol((char*)sdkVersionOutputBuffer.data(), NULL, 10); |
| } |
| |
| return api_level; |
| } |
| |
| void fastdeploy_set_local_agent(bool use_localagent) { |
| g_use_localagent = use_localagent; |
| } |
| |
| // local_path - must start with a '/' and be relative to $ANDROID_PRODUCT_OUT |
| static std::string get_agent_component_host_path(const char* local_path, const char* sdk_path) { |
| std::string adb_dir = android::base::GetExecutableDirectory(); |
| if (adb_dir.empty()) { |
| error_exit("Could not determine location of adb!"); |
| } |
| |
| if (g_use_localagent) { |
| const char* product_out = getenv("ANDROID_PRODUCT_OUT"); |
| if (product_out == nullptr) { |
| error_exit("Could not locate %s because $ANDROID_PRODUCT_OUT is not defined", |
| local_path); |
| } |
| return android::base::StringPrintf("%s%s", product_out, local_path); |
| } else { |
| return adb_dir + sdk_path; |
| } |
| } |
| |
| static bool deploy_agent(bool checkTimeStamps) { |
| std::vector<const char*> srcs; |
| std::string jar_path = |
| get_agent_component_host_path("/system/framework/deployagent.jar", "/deployagent.jar"); |
| std::string script_path = |
| get_agent_component_host_path("/system/bin/deployagent", "/deployagent"); |
| srcs.push_back(jar_path.c_str()); |
| srcs.push_back(script_path.c_str()); |
| |
| if (do_sync_push(srcs, kDeviceAgentPath, checkTimeStamps)) { |
| // on windows the shell script might have lost execute permission |
| // so need to set this explicitly |
| const char* kChmodCommandPattern = "chmod 777 %sdeployagent"; |
| std::string chmodCommand = |
| android::base::StringPrintf(kChmodCommandPattern, kDeviceAgentPath); |
| int ret = send_shell_command(chmodCommand); |
| if (ret != 0) { |
| error_exit("Error executing %s returncode: %d", chmodCommand.c_str(), ret); |
| } |
| } else { |
| error_exit("Error pushing agent files to device"); |
| } |
| |
| return true; |
| } |
| |
| void update_agent(FastDeploy_AgentUpdateStrategy agentUpdateStrategy) { |
| long agent_version = get_agent_version(); |
| switch (agentUpdateStrategy) { |
| case FastDeploy_AgentUpdateAlways: |
| deploy_agent(false); |
| break; |
| case FastDeploy_AgentUpdateNewerTimeStamp: |
| deploy_agent(true); |
| break; |
| case FastDeploy_AgentUpdateDifferentVersion: |
| if (agent_version != kRequiredAgentVersion) { |
| if (agent_version < 0) { |
| printf("Could not detect agent on device, deploying\n"); |
| } else { |
| printf("Device agent version is (%ld), (%ld) is required, re-deploying\n", |
| agent_version, kRequiredAgentVersion); |
| } |
| deploy_agent(false); |
| } |
| break; |
| } |
| |
| agent_version = get_agent_version(); |
| if (agent_version != kRequiredAgentVersion) { |
| error_exit("After update agent version remains incorrect! Expected %ld but version is %ld", |
| kRequiredAgentVersion, agent_version); |
| } |
| } |
| |
| static std::string get_string_from_utf16(const char16_t* input, int input_len) { |
| ssize_t utf8_length = utf16_to_utf8_length(input, input_len); |
| if (utf8_length <= 0) { |
| return {}; |
| } |
| std::string utf8; |
| utf8.resize(utf8_length); |
| utf16_to_utf8(input, input_len, &*utf8.begin(), utf8_length + 1); |
| return utf8; |
| } |
| |
| static std::string get_packagename_from_apk(const char* apkPath) { |
| #undef open |
| std::unique_ptr<android::ZipFileRO> zipFile(android::ZipFileRO::open(apkPath)); |
| #define open ___xxx_unix_open |
| if (zipFile == nullptr) { |
| perror_exit("Could not open %s", apkPath); |
| } |
| android::ZipEntryRO entry = zipFile->findEntryByName("AndroidManifest.xml"); |
| if (entry == nullptr) { |
| error_exit("Could not find AndroidManifest.xml inside %s", apkPath); |
| } |
| uint32_t manifest_len = 0; |
| if (!zipFile->getEntryInfo(entry, NULL, &manifest_len, NULL, NULL, NULL, NULL)) { |
| error_exit("Could not read AndroidManifest.xml inside %s", apkPath); |
| } |
| std::vector<char> manifest_data(manifest_len); |
| if (!zipFile->uncompressEntry(entry, manifest_data.data(), manifest_len)) { |
| error_exit("Could not uncompress AndroidManifest.xml inside %s", apkPath); |
| } |
| android::ResXMLTree tree; |
| android::status_t setto_status = tree.setTo(manifest_data.data(), manifest_len, true); |
| if (setto_status != android::OK) { |
| error_exit("Could not parse AndroidManifest.xml inside %s", apkPath); |
| } |
| android::ResXMLParser::event_code_t code; |
| while ((code = tree.next()) != android::ResXMLParser::BAD_DOCUMENT && |
| code != android::ResXMLParser::END_DOCUMENT) { |
| switch (code) { |
| case android::ResXMLParser::START_TAG: { |
| size_t element_name_length; |
| const char16_t* element_name = tree.getElementName(&element_name_length); |
| if (element_name == nullptr) { |
| continue; |
| } |
| std::u16string element_name_string(element_name, element_name_length); |
| if (element_name_string == u"manifest") { |
| for (size_t i = 0; i < tree.getAttributeCount(); i++) { |
| size_t attribute_name_length; |
| const char16_t* attribute_name_text = |
| tree.getAttributeName(i, &attribute_name_length); |
| if (attribute_name_text == nullptr) { |
| continue; |
| } |
| std::u16string attribute_name_string(attribute_name_text, |
| attribute_name_length); |
| if (attribute_name_string == u"package") { |
| size_t attribute_value_length; |
| const char16_t* attribute_value_text = |
| tree.getAttributeStringValue(i, &attribute_value_length); |
| if (attribute_value_text == nullptr) { |
| continue; |
| } |
| return get_string_from_utf16(attribute_value_text, |
| attribute_value_length); |
| } |
| } |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| error_exit("Could not find package name tag in AndroidManifest.xml inside %s", apkPath); |
| } |
| |
| void extract_metadata(const char* apkPath, FILE* outputFp) { |
| std::string packageName = get_packagename_from_apk(apkPath); |
| const char* kAgentExtractCommandPattern = "/data/local/tmp/deployagent extract %s"; |
| std::string extractCommand = |
| android::base::StringPrintf(kAgentExtractCommandPattern, packageName.c_str()); |
| |
| std::vector<char> extractErrorBuffer; |
| DeployAgentFileCallback cb(outputFp, &extractErrorBuffer); |
| int returnCode = send_shell_command(extractCommand, false, &cb); |
| if (returnCode != 0) { |
| fprintf(stderr, "Executing %s returned %d\n", extractCommand.c_str(), returnCode); |
| fprintf(stderr, "%*s\n", int(extractErrorBuffer.size()), extractErrorBuffer.data()); |
| error_exit("Aborting"); |
| } |
| } |
| |
| static std::string get_patch_generator_command() { |
| if (g_use_localagent) { |
| // This should never happen on a Windows machine |
| const char* host_out = getenv("ANDROID_HOST_OUT"); |
| if (host_out == nullptr) { |
| error_exit( |
| "Could not locate deploypatchgenerator.jar because $ANDROID_HOST_OUT " |
| "is not defined"); |
| } |
| return android::base::StringPrintf("java -jar %s/framework/deploypatchgenerator.jar", |
| host_out); |
| } |
| |
| std::string adb_dir = android::base::GetExecutableDirectory(); |
| if (adb_dir.empty()) { |
| error_exit("Could not locate deploypatchgenerator.jar"); |
| } |
| return android::base::StringPrintf(R"(java -jar "%s/deploypatchgenerator.jar")", |
| adb_dir.c_str()); |
| } |
| |
| void create_patch(const char* apkPath, const char* metadataPath, const char* patchPath) { |
| std::string generatePatchCommand = android::base::StringPrintf( |
| R"(%s "%s" "%s" > "%s")", get_patch_generator_command().c_str(), apkPath, metadataPath, |
| patchPath); |
| int returnCode = system(generatePatchCommand.c_str()); |
| if (returnCode != 0) { |
| error_exit("Executing %s returned %d", generatePatchCommand.c_str(), returnCode); |
| } |
| } |
| |
| std::string get_patch_path(const char* apkPath) { |
| std::string packageName = get_packagename_from_apk(apkPath); |
| std::string patchDevicePath = |
| android::base::StringPrintf("%s%s.patch", kDeviceAgentPath, packageName.c_str()); |
| return patchDevicePath; |
| } |
| |
| void apply_patch_on_device(const char* apkPath, const char* patchPath, const char* outputPath) { |
| const std::string kAgentApplyCommandPattern = "/data/local/tmp/deployagent apply %s %s -o %s"; |
| std::string packageName = get_packagename_from_apk(apkPath); |
| std::string patchDevicePath = get_patch_path(apkPath); |
| |
| std::vector<const char*> srcs = {patchPath}; |
| bool push_ok = do_sync_push(srcs, patchDevicePath.c_str(), false); |
| if (!push_ok) { |
| error_exit("Error pushing %s to %s returned", patchPath, patchDevicePath.c_str()); |
| } |
| |
| std::string applyPatchCommand = |
| android::base::StringPrintf(kAgentApplyCommandPattern.c_str(), packageName.c_str(), |
| patchDevicePath.c_str(), outputPath); |
| |
| int returnCode = send_shell_command(applyPatchCommand); |
| if (returnCode != 0) { |
| error_exit("Executing %s returned %d", applyPatchCommand.c_str(), returnCode); |
| } |
| } |
| |
| void install_patch(const char* apkPath, const char* patchPath, int argc, const char** argv) { |
| const std::string kAgentApplyCommandPattern = "/data/local/tmp/deployagent apply %s %s -pm %s"; |
| std::string packageName = get_packagename_from_apk(apkPath); |
| |
| std::string patchDevicePath = |
| android::base::StringPrintf("%s%s.patch", kDeviceAgentPath, packageName.c_str()); |
| |
| std::vector<const char*> srcs{patchPath}; |
| bool push_ok = do_sync_push(srcs, patchDevicePath.c_str(), false); |
| if (!push_ok) { |
| error_exit("Error pushing %s to %s returned", patchPath, patchDevicePath.c_str()); |
| } |
| |
| std::vector<unsigned char> applyOutputBuffer; |
| std::vector<unsigned char> applyErrorBuffer; |
| std::string argsString; |
| |
| bool rSwitchPresent = false; |
| for (int i = 0; i < argc; i++) { |
| argsString.append(argv[i]); |
| argsString.append(" "); |
| if (!strcmp(argv[i], "-r")) { |
| rSwitchPresent = true; |
| } |
| } |
| if (!rSwitchPresent) { |
| argsString.append("-r"); |
| } |
| |
| std::string applyPatchCommand = |
| android::base::StringPrintf(kAgentApplyCommandPattern.c_str(), packageName.c_str(), |
| patchDevicePath.c_str(), argsString.c_str()); |
| int returnCode = send_shell_command(applyPatchCommand); |
| if (returnCode != 0) { |
| error_exit("Executing %s returned %d", applyPatchCommand.c_str(), returnCode); |
| } |
| } |
| |
| bool find_package(const char* apkPath) { |
| const std::string findCommand = |
| "/data/local/tmp/deployagent find " + get_packagename_from_apk(apkPath); |
| return !send_shell_command(findCommand); |
| } |
