adb/client/fastdeploy.cpp - android_system_core - Gitiles

 /*
  * 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);
 }
	/*
	* 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);
	}