1 /*
2  * Copyright (C) 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "fastdeploy.h"
18 
19 #include <string.h>
20 #include <algorithm>
21 #include <array>
22 #include <memory>
23 
24 #include "android-base/file.h"
25 #include "android-base/strings.h"
26 #include "androidfw/ResourceTypes.h"
27 #include "androidfw/ZipFileRO.h"
28 #include "client/file_sync_client.h"
29 #include "commandline.h"
30 #include "deployagent.inc"        // Generated include via build rule.
31 #include "deployagentscript.inc"  // Generated include via build rule.
32 #include "fastdeploy/deploypatchgenerator/deploy_patch_generator.h"
33 #include "fastdeploy/deploypatchgenerator/patch_utils.h"
34 #include "fastdeploy/proto/ApkEntry.pb.h"
35 #include "fastdeploycallbacks.h"
36 #include "sysdeps.h"
37 
38 #include "adb_utils.h"
39 
40 static constexpr long kRequiredAgentVersion = 0x00000003;
41 
42 static constexpr int kPackageMissing = 3;
43 static constexpr int kInvalidAgentVersion = 4;
44 
45 static constexpr const char* kDeviceAgentFile = "/data/local/tmp/deployagent.jar";
46 static constexpr const char* kDeviceAgentScript = "/data/local/tmp/deployagent";
47 
48 static constexpr bool g_verbose_timings = false;
49 static FastDeploy_AgentUpdateStrategy g_agent_update_strategy =
50         FastDeploy_AgentUpdateDifferentVersion;
51 
52 using APKMetaData = com::android::fastdeploy::APKMetaData;
53 
54 namespace {
55 
56 struct TimeReporter {
57     TimeReporter(const char* label) : label_(label) {}
58     ~TimeReporter() {
59         if (g_verbose_timings) {
60             auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
61                     std::chrono::steady_clock::now() - start_);
62             fprintf(stderr, "%s finished in %lldms\n", label_,
63                     static_cast<long long>(duration.count()));
64         }
65     }
66 
67   private:
68     const char* label_;
69     std::chrono::steady_clock::time_point start_ = std::chrono::steady_clock::now();
70 };
71 #define REPORT_FUNC_TIME() TimeReporter reporter(__func__)
72 
73 struct FileDeleter {
74     FileDeleter(const char* path) : path_(path) {}
75     ~FileDeleter() { adb_unlink(path_); }
76 
77   private:
78     const char* const path_;
79 };
80 
81 }  // namespace
82 
83 int get_device_api_level() {
84     static const int api_level = [] {
85         REPORT_FUNC_TIME();
86         std::vector<char> sdk_version_output_buffer;
87         std::vector<char> sdk_version_error_buffer;
88         int api_level = -1;
89 
90         int status_code =
91                 capture_shell_command("getprop ro.build.version.sdk", &sdk_version_output_buffer,
92                                       &sdk_version_error_buffer);
93         if (status_code == 0 && sdk_version_output_buffer.size() > 0) {
94             api_level = strtol((char*)sdk_version_output_buffer.data(), nullptr, 10);
95         }
96 
97         return api_level;
98     }();
99     return api_level;
100 }
101 
102 void fastdeploy_set_agent_update_strategy(FastDeploy_AgentUpdateStrategy agent_update_strategy) {
103     g_agent_update_strategy = agent_update_strategy;
104 }
105 
106 static void push_to_device(const void* data, size_t byte_count, const char* dst, bool sync) {
107     std::vector<const char*> srcs;
108     TemporaryFile tf;
109     android::base::WriteFully(tf.fd, data, byte_count);
110     srcs.push_back(tf.path);
111     // On Windows, the file needs to be flushed before pushing to device,
112     // but can't be removed until after the push.
113     unix_close(tf.release());
114 
115     if (!do_sync_push(srcs, dst, sync, CompressionType::Any, false)) {
116         error_exit("Failed to push fastdeploy agent to device.");
117     }
118 }
119 
120 static bool deploy_agent(bool check_time_stamps) {
121     REPORT_FUNC_TIME();
122 
123     push_to_device(kDeployAgent, sizeof(kDeployAgent), kDeviceAgentFile, check_time_stamps);
124     push_to_device(kDeployAgentScript, sizeof(kDeployAgentScript), kDeviceAgentScript,
125                    check_time_stamps);
126 
127     // on windows the shell script might have lost execute permission
128     // so need to set this explicitly
129     const char* kChmodCommandPattern = "chmod 777 %s";
130     std::string chmod_command =
131             android::base::StringPrintf(kChmodCommandPattern, kDeviceAgentScript);
132     int ret = send_shell_command(chmod_command);
133     if (ret != 0) {
134         error_exit("Error executing %s returncode: %d", chmod_command.c_str(), ret);
135     }
136 
137     return true;
138 }
139 
140 static std::string get_string_from_utf16(const char16_t* input, int input_len) {
141     ssize_t utf8_length = utf16_to_utf8_length(input, input_len);
142     if (utf8_length <= 0) {
143         return {};
144     }
145     std::string utf8;
146     utf8.resize(utf8_length);
147     utf16_to_utf8(input, input_len, &*utf8.begin(), utf8_length + 1);
148     return utf8;
149 }
150 
151 static std::string get_package_name_from_apk(const char* apk_path) {
152 #undef open
153     std::unique_ptr<android::ZipFileRO> zip_file((android::ZipFileRO::open)(apk_path));
154 #define open ___xxx_unix_open
155     if (zip_file == nullptr) {
156         perror_exit("Could not open %s", apk_path);
157     }
158     android::ZipEntryRO entry = zip_file->findEntryByName("AndroidManifest.xml");
159     if (entry == nullptr) {
160         error_exit("Could not find AndroidManifest.xml inside %s", apk_path);
161     }
162     uint32_t manifest_len = 0;
163     if (!zip_file->getEntryInfo(entry, NULL, &manifest_len, NULL, NULL, NULL, NULL)) {
164         error_exit("Could not read AndroidManifest.xml inside %s", apk_path);
165     }
166     std::vector<char> manifest_data(manifest_len);
167     if (!zip_file->uncompressEntry(entry, manifest_data.data(), manifest_len)) {
168         error_exit("Could not uncompress AndroidManifest.xml inside %s", apk_path);
169     }
170     android::ResXMLTree tree;
171     android::status_t setto_status = tree.setTo(manifest_data.data(), manifest_len, true);
172     if (setto_status != android::OK) {
173         error_exit("Could not parse AndroidManifest.xml inside %s", apk_path);
174     }
175     android::ResXMLParser::event_code_t code;
176     while ((code = tree.next()) != android::ResXMLParser::BAD_DOCUMENT &&
177            code != android::ResXMLParser::END_DOCUMENT) {
178         switch (code) {
179             case android::ResXMLParser::START_TAG: {
180                 size_t element_name_length;
181                 const char16_t* element_name = tree.getElementName(&element_name_length);
182                 if (element_name == nullptr) {
183                     continue;
184                 }
185                 std::u16string element_name_string(element_name, element_name_length);
186                 if (element_name_string == u"manifest") {
187                     for (size_t i = 0; i < tree.getAttributeCount(); i++) {
188                         size_t attribute_name_length;
189                         const char16_t* attribute_name_text =
190                                 tree.getAttributeName(i, &attribute_name_length);
191                         if (attribute_name_text == nullptr) {
192                             continue;
193                         }
194                         std::u16string attribute_name_string(attribute_name_text,
195                                                              attribute_name_length);
196                         if (attribute_name_string == u"package") {
197                             size_t attribute_value_length;
198                             const char16_t* attribute_value_text =
199                                     tree.getAttributeStringValue(i, &attribute_value_length);
200                             if (attribute_value_text == nullptr) {
201                                 continue;
202                             }
203                             return get_string_from_utf16(attribute_value_text,
204                                                          attribute_value_length);
205                         }
206                     }
207                 }
208                 break;
209             }
210             default:
211                 break;
212         }
213     }
214     error_exit("Could not find package name tag in AndroidManifest.xml inside %s", apk_path);
215 }
216 
217 static long parse_agent_version(const std::vector<char>& version_buffer) {
218     long version = -1;
219     if (!version_buffer.empty()) {
220         version = strtol((char*)version_buffer.data(), NULL, 16);
221     }
222     return version;
223 }
224 
225 static void update_agent_if_necessary() {
226     switch (g_agent_update_strategy) {
227         case FastDeploy_AgentUpdateAlways:
228             deploy_agent(/*check_time_stamps=*/false);
229             break;
230         case FastDeploy_AgentUpdateNewerTimeStamp:
231             deploy_agent(/*check_time_stamps=*/true);
232             break;
233         default:
234             break;
235     }
236 }
237 
238 std::optional<APKMetaData> extract_metadata(const char* apk_path) {
239     // Update agent if there is a command line argument forcing to do so.
240     update_agent_if_necessary();
241 
242     REPORT_FUNC_TIME();
243 
244     std::string package_name = get_package_name_from_apk(apk_path);
245 
246     // Dump apk command checks the required vs current agent version and if they match then returns
247     // the APK dump for package. Doing this in a single call saves round-trip and agent launch time.
248     constexpr const char* kAgentDumpCommandPattern = "/data/local/tmp/deployagent dump %ld %s";
249     std::string dump_command = android::base::StringPrintf(
250             kAgentDumpCommandPattern, kRequiredAgentVersion, package_name.c_str());
251 
252     std::vector<char> dump_out_buffer;
253     std::vector<char> dump_error_buffer;
254     int returnCode =
255             capture_shell_command(dump_command.c_str(), &dump_out_buffer, &dump_error_buffer);
256     if (returnCode >= kInvalidAgentVersion) {
257         // Agent has wrong version or missing.
258         long agent_version = parse_agent_version(dump_out_buffer);
259         if (agent_version < 0) {
260             printf("Could not detect agent on device, deploying\n");
261         } else {
262             printf("Device agent version is (%ld), (%ld) is required, re-deploying\n",
263                    agent_version, kRequiredAgentVersion);
264         }
265         deploy_agent(/*check_time_stamps=*/false);
266 
267         // Retry with new agent.
268         dump_out_buffer.clear();
269         dump_error_buffer.clear();
270         returnCode =
271                 capture_shell_command(dump_command.c_str(), &dump_out_buffer, &dump_error_buffer);
272     }
273     if (returnCode != 0) {
274         if (returnCode == kInvalidAgentVersion) {
275             long agent_version = parse_agent_version(dump_out_buffer);
276             error_exit(
277                     "After update agent version remains incorrect! Expected %ld but version is %ld",
278                     kRequiredAgentVersion, agent_version);
279         }
280         if (returnCode == kPackageMissing) {
281             fprintf(stderr, "Package %s not found, falling back to install\n",
282                     package_name.c_str());
283             return {};
284         }
285         fprintf(stderr, "Executing %s returned %d\n", dump_command.c_str(), returnCode);
286         fprintf(stderr, "%*s\n", int(dump_error_buffer.size()), dump_error_buffer.data());
287         error_exit("Aborting");
288     }
289 
290     com::android::fastdeploy::APKDump dump;
291     if (!dump.ParseFromArray(dump_out_buffer.data(), dump_out_buffer.size())) {
292         fprintf(stderr, "Can't parse output of %s\n", dump_command.c_str());
293         error_exit("Aborting");
294     }
295 
296     return PatchUtils::GetDeviceAPKMetaData(dump);
297 }
298 
299 unique_fd install_patch(int argc, const char** argv) {
300     REPORT_FUNC_TIME();
301     constexpr char kAgentApplyServicePattern[] = "shell:/data/local/tmp/deployagent apply - -pm %s";
302 
303     std::vector<unsigned char> apply_output_buffer;
304     std::vector<unsigned char> apply_error_buffer;
305     std::string argsString;
306 
307     bool rSwitchPresent = false;
308     for (int i = 0; i < argc; i++) {
309         argsString.append(argv[i]);
310         argsString.append(" ");
311         if (!strcmp(argv[i], "-r")) {
312             rSwitchPresent = true;
313         }
314     }
315     if (!rSwitchPresent) {
316         argsString.append("-r");
317     }
318 
319     std::string error;
320     std::string apply_patch_service_string =
321             android::base::StringPrintf(kAgentApplyServicePattern, argsString.c_str());
322     unique_fd fd{adb_connect(apply_patch_service_string, &error)};
323     if (fd < 0) {
324         error_exit("Executing %s returned %s", apply_patch_service_string.c_str(), error.c_str());
325     }
326     return fd;
327 }
328 
329 unique_fd apply_patch_on_device(const char* output_path) {
330     REPORT_FUNC_TIME();
331     constexpr char kAgentApplyServicePattern[] = "shell:/data/local/tmp/deployagent apply - -o %s";
332 
333     std::string error;
334     std::string apply_patch_service_string =
335             android::base::StringPrintf(kAgentApplyServicePattern, output_path);
336     unique_fd fd{adb_connect(apply_patch_service_string, &error)};
337     if (fd < 0) {
338         error_exit("Executing %s returned %s", apply_patch_service_string.c_str(), error.c_str());
339     }
340     return fd;
341 }
342 
343 static void create_patch(const char* apk_path, APKMetaData metadata, borrowed_fd patch_fd) {
344     REPORT_FUNC_TIME();
345     DeployPatchGenerator generator(/*is_verbose=*/false);
346     bool success = generator.CreatePatch(apk_path, std::move(metadata), patch_fd);
347     if (!success) {
348         error_exit("Failed to create patch for %s", apk_path);
349     }
350 }
351 
352 int stream_patch(const char* apk_path, APKMetaData metadata, unique_fd patch_fd) {
353     create_patch(apk_path, std::move(metadata), patch_fd);
354 
355     REPORT_FUNC_TIME();
356     return read_and_dump(patch_fd.get());
357 }
358