1 /*
2 * Copyright (C) 2017 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 agree 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 <stdio.h>
18 #include <unistd.h>
19
20 #include <string>
21 #include <vector>
22
23 #include <android-base/file.h>
24 #include <android-base/properties.h>
25 #include <android-base/strings.h>
26 #include <android-base/test_utils.h>
27 #include <gtest/gtest.h>
28 #include <vintf/VintfObjectRecovery.h>
29 #include <ziparchive/zip_archive.h>
30 #include <ziparchive/zip_writer.h>
31
32 #include "install.h"
33 #include "private/install.h"
34
TEST(InstallTest,verify_package_compatibility_no_entry)35 TEST(InstallTest, verify_package_compatibility_no_entry) {
36 TemporaryFile temp_file;
37 FILE* zip_file = fdopen(temp_file.fd, "w");
38 ZipWriter writer(zip_file);
39 // The archive must have something to be opened correctly.
40 ASSERT_EQ(0, writer.StartEntry("dummy_entry", 0));
41 ASSERT_EQ(0, writer.FinishEntry());
42 ASSERT_EQ(0, writer.Finish());
43 ASSERT_EQ(0, fclose(zip_file));
44
45 // Doesn't contain compatibility zip entry.
46 ZipArchiveHandle zip;
47 ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
48 ASSERT_TRUE(verify_package_compatibility(zip));
49 CloseArchive(zip);
50 }
51
TEST(InstallTest,verify_package_compatibility_invalid_entry)52 TEST(InstallTest, verify_package_compatibility_invalid_entry) {
53 TemporaryFile temp_file;
54 FILE* zip_file = fdopen(temp_file.fd, "w");
55 ZipWriter writer(zip_file);
56 ASSERT_EQ(0, writer.StartEntry("compatibility.zip", 0));
57 ASSERT_EQ(0, writer.FinishEntry());
58 ASSERT_EQ(0, writer.Finish());
59 ASSERT_EQ(0, fclose(zip_file));
60
61 // Empty compatibility zip entry.
62 ZipArchiveHandle zip;
63 ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
64 ASSERT_FALSE(verify_package_compatibility(zip));
65 CloseArchive(zip);
66 }
67
TEST(InstallTest,verify_package_compatibility_with_libvintf_malformed_xml)68 TEST(InstallTest, verify_package_compatibility_with_libvintf_malformed_xml) {
69 TemporaryFile compatibility_zip_file;
70 FILE* compatibility_zip = fdopen(compatibility_zip_file.fd, "w");
71 ZipWriter compatibility_zip_writer(compatibility_zip);
72 ASSERT_EQ(0, compatibility_zip_writer.StartEntry("system_manifest.xml", kCompressDeflated));
73 std::string malformed_xml = "malformed";
74 ASSERT_EQ(0, compatibility_zip_writer.WriteBytes(malformed_xml.data(), malformed_xml.size()));
75 ASSERT_EQ(0, compatibility_zip_writer.FinishEntry());
76 ASSERT_EQ(0, compatibility_zip_writer.Finish());
77 ASSERT_EQ(0, fclose(compatibility_zip));
78
79 TemporaryFile temp_file;
80 FILE* zip_file = fdopen(temp_file.fd, "w");
81 ZipWriter writer(zip_file);
82 ASSERT_EQ(0, writer.StartEntry("compatibility.zip", kCompressStored));
83 std::string compatibility_zip_content;
84 ASSERT_TRUE(
85 android::base::ReadFileToString(compatibility_zip_file.path, &compatibility_zip_content));
86 ASSERT_EQ(0,
87 writer.WriteBytes(compatibility_zip_content.data(), compatibility_zip_content.size()));
88 ASSERT_EQ(0, writer.FinishEntry());
89 ASSERT_EQ(0, writer.Finish());
90 ASSERT_EQ(0, fclose(zip_file));
91
92 ZipArchiveHandle zip;
93 ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
94 std::vector<std::string> compatibility_info;
95 compatibility_info.push_back(malformed_xml);
96 // Malformed compatibility zip is expected to be rejected by libvintf. But we defer that to
97 // libvintf.
98 std::string err;
99 bool result =
100 android::vintf::VintfObjectRecovery::CheckCompatibility(compatibility_info, &err) == 0;
101 ASSERT_EQ(result, verify_package_compatibility(zip));
102 CloseArchive(zip);
103 }
104
TEST(InstallTest,verify_package_compatibility_with_libvintf_system_manifest_xml)105 TEST(InstallTest, verify_package_compatibility_with_libvintf_system_manifest_xml) {
106 static constexpr const char* system_manifest_xml_path = "/system/manifest.xml";
107 if (access(system_manifest_xml_path, R_OK) == -1) {
108 GTEST_LOG_(INFO) << "Test skipped on devices w/o /system/manifest.xml.";
109 return;
110 }
111 std::string system_manifest_xml_content;
112 ASSERT_TRUE(
113 android::base::ReadFileToString(system_manifest_xml_path, &system_manifest_xml_content));
114 TemporaryFile compatibility_zip_file;
115 FILE* compatibility_zip = fdopen(compatibility_zip_file.fd, "w");
116 ZipWriter compatibility_zip_writer(compatibility_zip);
117 ASSERT_EQ(0, compatibility_zip_writer.StartEntry("system_manifest.xml", kCompressDeflated));
118 ASSERT_EQ(0, compatibility_zip_writer.WriteBytes(system_manifest_xml_content.data(),
119 system_manifest_xml_content.size()));
120 ASSERT_EQ(0, compatibility_zip_writer.FinishEntry());
121 ASSERT_EQ(0, compatibility_zip_writer.Finish());
122 ASSERT_EQ(0, fclose(compatibility_zip));
123
124 TemporaryFile temp_file;
125 FILE* zip_file = fdopen(temp_file.fd, "w");
126 ZipWriter writer(zip_file);
127 ASSERT_EQ(0, writer.StartEntry("compatibility.zip", kCompressStored));
128 std::string compatibility_zip_content;
129 ASSERT_TRUE(
130 android::base::ReadFileToString(compatibility_zip_file.path, &compatibility_zip_content));
131 ASSERT_EQ(0,
132 writer.WriteBytes(compatibility_zip_content.data(), compatibility_zip_content.size()));
133 ASSERT_EQ(0, writer.FinishEntry());
134 ASSERT_EQ(0, writer.Finish());
135 ASSERT_EQ(0, fclose(zip_file));
136
137 ZipArchiveHandle zip;
138 ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
139 std::vector<std::string> compatibility_info;
140 compatibility_info.push_back(system_manifest_xml_content);
141 std::string err;
142 bool result =
143 android::vintf::VintfObjectRecovery::CheckCompatibility(compatibility_info, &err) == 0;
144 // Make sure the result is consistent with libvintf library.
145 ASSERT_EQ(result, verify_package_compatibility(zip));
146 CloseArchive(zip);
147 }
148
TEST(InstallTest,update_binary_command_smoke)149 TEST(InstallTest, update_binary_command_smoke) {
150 #ifdef AB_OTA_UPDATER
151 TemporaryFile temp_file;
152 FILE* zip_file = fdopen(temp_file.fd, "w");
153 ZipWriter writer(zip_file);
154 ASSERT_EQ(0, writer.StartEntry("payload.bin", kCompressStored));
155 ASSERT_EQ(0, writer.FinishEntry());
156 ASSERT_EQ(0, writer.StartEntry("payload_properties.txt", kCompressStored));
157 const std::string properties = "some_properties";
158 ASSERT_EQ(0, writer.WriteBytes(properties.data(), properties.size()));
159 ASSERT_EQ(0, writer.FinishEntry());
160 // A metadata entry is mandatory.
161 ASSERT_EQ(0, writer.StartEntry("META-INF/com/android/metadata", kCompressStored));
162 std::string device = android::base::GetProperty("ro.product.device", "");
163 ASSERT_NE("", device);
164 std::string timestamp = android::base::GetProperty("ro.build.date.utc", "");
165 ASSERT_NE("", timestamp);
166 std::string metadata = android::base::Join(
167 std::vector<std::string>{
168 "ota-type=AB", "pre-device=" + device, "post-timestamp=" + timestamp,
169 },
170 "\n");
171 ASSERT_EQ(0, writer.WriteBytes(metadata.data(), metadata.size()));
172 ASSERT_EQ(0, writer.FinishEntry());
173 ASSERT_EQ(0, writer.Finish());
174 ASSERT_EQ(0, fclose(zip_file));
175
176 ZipArchiveHandle zip;
177 ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
178 int status_fd = 10;
179 std::string path = "/path/to/update.zip";
180 std::vector<std::string> cmd;
181 ASSERT_EQ(0, update_binary_command(path, zip, 0, status_fd, &cmd));
182 ASSERT_EQ("/sbin/update_engine_sideload", cmd[0]);
183 ASSERT_EQ("--payload=file://" + path, cmd[1]);
184 ASSERT_EQ("--headers=" + properties, cmd[3]);
185 ASSERT_EQ("--status_fd=" + std::to_string(status_fd), cmd[4]);
186 CloseArchive(zip);
187 #else
188 // Cannot test update_binary_command() because it tries to extract update-binary to /tmp.
189 GTEST_LOG_(INFO) << "Test skipped on non-A/B device.";
190 #endif // AB_OTA_UPDATER
191 }
192
TEST(InstallTest,update_binary_command_invalid)193 TEST(InstallTest, update_binary_command_invalid) {
194 #ifdef AB_OTA_UPDATER
195 TemporaryFile temp_file;
196 FILE* zip_file = fdopen(temp_file.fd, "w");
197 ZipWriter writer(zip_file);
198 // Missing payload_properties.txt.
199 ASSERT_EQ(0, writer.StartEntry("payload.bin", kCompressStored));
200 ASSERT_EQ(0, writer.FinishEntry());
201 // A metadata entry is mandatory.
202 ASSERT_EQ(0, writer.StartEntry("META-INF/com/android/metadata", kCompressStored));
203 std::string device = android::base::GetProperty("ro.product.device", "");
204 ASSERT_NE("", device);
205 std::string timestamp = android::base::GetProperty("ro.build.date.utc", "");
206 ASSERT_NE("", timestamp);
207 std::string metadata = android::base::Join(
208 std::vector<std::string>{
209 "ota-type=AB", "pre-device=" + device, "post-timestamp=" + timestamp,
210 },
211 "\n");
212 ASSERT_EQ(0, writer.WriteBytes(metadata.data(), metadata.size()));
213 ASSERT_EQ(0, writer.FinishEntry());
214 ASSERT_EQ(0, writer.Finish());
215 ASSERT_EQ(0, fclose(zip_file));
216
217 ZipArchiveHandle zip;
218 ASSERT_EQ(0, OpenArchive(temp_file.path, &zip));
219 int status_fd = 10;
220 std::string path = "/path/to/update.zip";
221 std::vector<std::string> cmd;
222 ASSERT_EQ(INSTALL_CORRUPT, update_binary_command(path, zip, 0, status_fd, &cmd));
223 CloseArchive(zip);
224 #else
225 // Cannot test update_binary_command() because it tries to extract update-binary to /tmp.
226 GTEST_LOG_(INFO) << "Test skipped on non-A/B device.";
227 #endif // AB_OTA_UPDATER
228 }
229