Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | # |
| 3 | # Copyright (C) 2008 The Android Open Source Project |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | |
| 17 | """ |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 18 | Given a target-files zipfile, produces an OTA package that installs that build. |
| 19 | An incremental OTA is produced if -i is given, otherwise a full OTA is produced. |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 20 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 21 | Usage: ota_from_target_files [options] input_target_files output_ota_package |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 22 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 23 | Common options that apply to both of non-A/B and A/B OTAs |
| 24 | |
| 25 | --downgrade |
| 26 | Intentionally generate an incremental OTA that updates from a newer build |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 27 | to an older one (e.g. downgrading from P preview back to O MR1). |
| 28 | "ota-downgrade=yes" will be set in the package metadata file. A data wipe |
| 29 | will always be enforced when using this flag, so "ota-wipe=yes" will also |
| 30 | be included in the metadata file. The update-binary in the source build |
| 31 | will be used in the OTA package, unless --binary flag is specified. Please |
| 32 | also check the comment for --override_timestamp below. |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 33 | |
| 34 | -i (--incremental_from) <file> |
| 35 | Generate an incremental OTA using the given target-files zip as the |
| 36 | starting build. |
| 37 | |
| 38 | -k (--package_key) <key> |
| 39 | Key to use to sign the package (default is the value of |
| 40 | default_system_dev_certificate from the input target-files's |
| 41 | META/misc_info.txt, or "build/target/product/security/testkey" if that |
| 42 | value is not specified). |
Doug Zongker | afb32ea | 2011-09-22 10:28:04 -0700 | [diff] [blame] | 43 | |
| 44 | For incremental OTAs, the default value is based on the source |
| 45 | target-file, not the target build. |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 46 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 47 | --override_timestamp |
| 48 | Intentionally generate an incremental OTA that updates from a newer build |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 49 | to an older one (based on timestamp comparison), by setting the downgrade |
| 50 | flag in the package metadata. This differs from --downgrade flag, as we |
| 51 | don't enforce a data wipe with this flag. Because we know for sure this is |
| 52 | NOT an actual downgrade case, but two builds happen to be cut in a reverse |
| 53 | order (e.g. from two branches). A legit use case is that we cut a new |
| 54 | build C (after having A and B), but want to enfore an update path of A -> |
| 55 | C -> B. Specifying --downgrade may not help since that would enforce a |
| 56 | data wipe for C -> B update. |
| 57 | |
| 58 | We used to set a fake timestamp in the package metadata for this flow. But |
| 59 | now we consolidate the two cases (i.e. an actual downgrade, or a downgrade |
| 60 | based on timestamp) with the same "ota-downgrade=yes" flag, with the |
| 61 | difference being whether "ota-wipe=yes" is set. |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 62 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 63 | --wipe_user_data |
| 64 | Generate an OTA package that will wipe the user data partition when |
| 65 | installed. |
| 66 | |
| 67 | Non-A/B OTA specific options |
| 68 | |
| 69 | -b (--binary) <file> |
| 70 | Use the given binary as the update-binary in the output package, instead |
| 71 | of the binary in the build's target_files. Use for development only. |
| 72 | |
| 73 | --block |
| 74 | Generate a block-based OTA for non-A/B device. We have deprecated the |
| 75 | support for file-based OTA since O. Block-based OTA will be used by |
| 76 | default for all non-A/B devices. Keeping this flag here to not break |
| 77 | existing callers. |
| 78 | |
| 79 | -e (--extra_script) <file> |
| 80 | Insert the contents of file at the end of the update script. |
Tao Bao | 43078aa | 2015-04-21 14:32:35 -0700 | [diff] [blame] | 81 | |
leozwang | aa6c1a1 | 2015-08-14 10:57:58 -0700 | [diff] [blame] | 82 | --full_bootloader |
| 83 | Similar to --full_radio. When generating an incremental OTA, always |
| 84 | include a full copy of bootloader image. |
| 85 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 86 | --full_radio |
| 87 | When generating an incremental OTA, always include a full copy of radio |
| 88 | image. This option is only meaningful when -i is specified, because a full |
| 89 | radio is always included in a full OTA if applicable. |
Michael Runge | 63f01de | 2014-10-28 19:24:19 -0700 | [diff] [blame] | 90 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 91 | --log_diff <file> |
| 92 | Generate a log file that shows the differences in the source and target |
| 93 | builds for an incremental package. This option is only meaningful when -i |
| 94 | is specified. |
| 95 | |
| 96 | -o (--oem_settings) <main_file[,additional_files...]> |
Alain Vongsouvanh | 7f804ba | 2017-02-16 13:06:55 -0800 | [diff] [blame] | 97 | Comma seperated list of files used to specify the expected OEM-specific |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 98 | properties on the OEM partition of the intended device. Multiple expected |
| 99 | values can be used by providing multiple files. Only the first dict will |
| 100 | be used to compute fingerprint, while the rest will be used to assert |
| 101 | OEM-specific properties. |
Alain Vongsouvanh | 7f804ba | 2017-02-16 13:06:55 -0800 | [diff] [blame] | 102 | |
Tao Bao | 8608cde | 2016-02-25 19:49:55 -0800 | [diff] [blame] | 103 | --oem_no_mount |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 104 | For devices with OEM-specific properties but without an OEM partition, do |
| 105 | not mount the OEM partition in the updater-script. This should be very |
| 106 | rarely used, since it's expected to have a dedicated OEM partition for |
| 107 | OEM-specific properties. Only meaningful when -o is specified. |
Tao Bao | 8608cde | 2016-02-25 19:49:55 -0800 | [diff] [blame] | 108 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 109 | --stash_threshold <float> |
| 110 | Specify the threshold that will be used to compute the maximum allowed |
| 111 | stash size (defaults to 0.8). |
Doug Zongker | dbfaae5 | 2009-04-21 17:12:54 -0700 | [diff] [blame] | 112 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 113 | -t (--worker_threads) <int> |
| 114 | Specify the number of worker-threads that will be used when generating |
| 115 | patches for incremental updates (defaults to 3). |
Tao Bao | 3e6161a | 2017-02-28 11:48:48 -0800 | [diff] [blame] | 116 | |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 117 | --verify |
| 118 | Verify the checksums of the updated system and vendor (if any) partitions. |
| 119 | Non-A/B incremental OTAs only. |
Doug Zongker | 1c390a2 | 2009-05-14 19:06:36 -0700 | [diff] [blame] | 120 | |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 121 | -2 (--two_step) |
Tao Bao | 30df8b4 | 2018-04-23 15:32:53 -0700 | [diff] [blame] | 122 | Generate a 'two-step' OTA package, where recovery is updated first, so |
| 123 | that any changes made to the system partition are done using the new |
| 124 | recovery (new kernel, etc.). |
| 125 | |
| 126 | A/B OTA specific options |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 127 | |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 128 | --include_secondary |
| 129 | Additionally include the payload for secondary slot images (default: |
| 130 | False). Only meaningful when generating A/B OTAs. |
| 131 | |
| 132 | By default, an A/B OTA package doesn't contain the images for the |
| 133 | secondary slot (e.g. system_other.img). Specifying this flag allows |
| 134 | generating a separate payload that will install secondary slot images. |
| 135 | |
| 136 | Such a package needs to be applied in a two-stage manner, with a reboot |
| 137 | in-between. During the first stage, the updater applies the primary |
| 138 | payload only. Upon finishing, it reboots the device into the newly updated |
| 139 | slot. It then continues to install the secondary payload to the inactive |
| 140 | slot, but without switching the active slot at the end (needs the matching |
| 141 | support in update_engine, i.e. SWITCH_SLOT_ON_REBOOT flag). |
| 142 | |
| 143 | Due to the special install procedure, the secondary payload will be always |
| 144 | generated as a full payload. |
| 145 | |
Tao Bao | dea0f8b | 2016-06-20 17:55:06 -0700 | [diff] [blame] | 146 | --payload_signer <signer> |
| 147 | Specify the signer when signing the payload and metadata for A/B OTAs. |
| 148 | By default (i.e. without this flag), it calls 'openssl pkeyutl' to sign |
| 149 | with the package private key. If the private key cannot be accessed |
| 150 | directly, a payload signer that knows how to do that should be specified. |
| 151 | The signer will be supplied with "-inkey <path_to_key>", |
| 152 | "-in <input_file>" and "-out <output_file>" parameters. |
Baligh Uddin | 2abbbd0 | 2016-06-22 12:14:16 -0700 | [diff] [blame] | 153 | |
| 154 | --payload_signer_args <args> |
| 155 | Specify the arguments needed for payload signer. |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 156 | |
| 157 | --skip_postinstall |
| 158 | Skip the postinstall hooks when generating an A/B OTA package (default: |
| 159 | False). Note that this discards ALL the hooks, including non-optional |
| 160 | ones. Should only be used if caller knows it's safe to do so (e.g. all the |
| 161 | postinstall work is to dexopt apps and a data wipe will happen immediately |
| 162 | after). Only meaningful when generating A/B OTAs. |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 163 | """ |
| 164 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 165 | from __future__ import print_function |
| 166 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 167 | import multiprocessing |
Tao Bao | 2dd1c48 | 2017-02-03 16:49:39 -0800 | [diff] [blame] | 168 | import os.path |
Baligh Uddin | 2abbbd0 | 2016-06-22 12:14:16 -0700 | [diff] [blame] | 169 | import shlex |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 170 | import shutil |
Tao Bao | 85f1698 | 2018-03-08 16:28:33 -0800 | [diff] [blame] | 171 | import struct |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 172 | import subprocess |
| 173 | import sys |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 174 | import tempfile |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 175 | import zipfile |
| 176 | |
| 177 | import common |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 178 | import edify_generator |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 179 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 180 | if sys.hexversion < 0x02070000: |
| 181 | print("Python 2.7 or newer is required.", file=sys.stderr) |
| 182 | sys.exit(1) |
| 183 | |
| 184 | |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 185 | OPTIONS = common.OPTIONS |
Doug Zongker | afb32ea | 2011-09-22 10:28:04 -0700 | [diff] [blame] | 186 | OPTIONS.package_key = None |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 187 | OPTIONS.incremental_source = None |
Michael Runge | 63f01de | 2014-10-28 19:24:19 -0700 | [diff] [blame] | 188 | OPTIONS.verify = False |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 189 | OPTIONS.patch_threshold = 0.95 |
Doug Zongker | dbfaae5 | 2009-04-21 17:12:54 -0700 | [diff] [blame] | 190 | OPTIONS.wipe_user_data = False |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 191 | OPTIONS.downgrade = False |
Doug Zongker | 1c390a2 | 2009-05-14 19:06:36 -0700 | [diff] [blame] | 192 | OPTIONS.extra_script = None |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 193 | OPTIONS.worker_threads = multiprocessing.cpu_count() // 2 |
| 194 | if OPTIONS.worker_threads == 0: |
| 195 | OPTIONS.worker_threads = 1 |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 196 | OPTIONS.two_step = False |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 197 | OPTIONS.include_secondary = False |
Takeshi Kanemoto | e153b34 | 2013-11-14 17:20:50 +0900 | [diff] [blame] | 198 | OPTIONS.no_signing = False |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 199 | OPTIONS.block_based = True |
Doug Zongker | 2556848 | 2014-03-03 10:21:27 -0800 | [diff] [blame] | 200 | OPTIONS.updater_binary = None |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 201 | OPTIONS.oem_source = None |
Tao Bao | 8608cde | 2016-02-25 19:49:55 -0800 | [diff] [blame] | 202 | OPTIONS.oem_no_mount = False |
Tao Bao | 43078aa | 2015-04-21 14:32:35 -0700 | [diff] [blame] | 203 | OPTIONS.full_radio = False |
leozwang | aa6c1a1 | 2015-08-14 10:57:58 -0700 | [diff] [blame] | 204 | OPTIONS.full_bootloader = False |
Tao Bao | d47d8e1 | 2015-05-21 14:09:49 -0700 | [diff] [blame] | 205 | # Stash size cannot exceed cache_size * threshold. |
| 206 | OPTIONS.cache_size = None |
| 207 | OPTIONS.stash_threshold = 0.8 |
Tao Bao | d62c603 | 2015-11-30 09:40:20 -0800 | [diff] [blame] | 208 | OPTIONS.log_diff = None |
Tao Bao | dea0f8b | 2016-06-20 17:55:06 -0700 | [diff] [blame] | 209 | OPTIONS.payload_signer = None |
Baligh Uddin | 2abbbd0 | 2016-06-22 12:14:16 -0700 | [diff] [blame] | 210 | OPTIONS.payload_signer_args = [] |
Tao Bao | 5f8ff93 | 2017-03-21 22:35:00 -0700 | [diff] [blame] | 211 | OPTIONS.extracted_input = None |
Christian Oder | f63e2cd | 2017-05-01 22:30:15 +0200 | [diff] [blame] | 212 | OPTIONS.key_passwords = [] |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 213 | OPTIONS.skip_postinstall = False |
| 214 | |
Tao Bao | 8dcf738 | 2015-05-21 14:09:49 -0700 | [diff] [blame] | 215 | |
Tao Bao | 2dd1c48 | 2017-02-03 16:49:39 -0800 | [diff] [blame] | 216 | METADATA_NAME = 'META-INF/com/android/metadata' |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 217 | POSTINSTALL_CONFIG = 'META/postinstall_config.txt' |
Tao Bao | 6b0b2f9 | 2017-03-05 11:38:11 -0800 | [diff] [blame] | 218 | UNZIP_PATTERN = ['IMAGES/*', 'META/*'] |
| 219 | |
Tao Bao | 2dd1c48 | 2017-02-03 16:49:39 -0800 | [diff] [blame] | 220 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 221 | class BuildInfo(object): |
| 222 | """A class that holds the information for a given build. |
| 223 | |
| 224 | This class wraps up the property querying for a given source or target build. |
| 225 | It abstracts away the logic of handling OEM-specific properties, and caches |
| 226 | the commonly used properties such as fingerprint. |
| 227 | |
| 228 | There are two types of info dicts: a) build-time info dict, which is generated |
| 229 | at build time (i.e. included in a target_files zip); b) OEM info dict that is |
| 230 | specified at package generation time (via command line argument |
| 231 | '--oem_settings'). If a build doesn't use OEM-specific properties (i.e. not |
| 232 | having "oem_fingerprint_properties" in build-time info dict), all the queries |
| 233 | would be answered based on build-time info dict only. Otherwise if using |
| 234 | OEM-specific properties, some of them will be calculated from two info dicts. |
| 235 | |
| 236 | Users can query properties similarly as using a dict() (e.g. info['fstab']), |
| 237 | or to query build properties via GetBuildProp() or GetVendorBuildProp(). |
| 238 | |
| 239 | Attributes: |
| 240 | info_dict: The build-time info dict. |
| 241 | is_ab: Whether it's a build that uses A/B OTA. |
| 242 | oem_dicts: A list of OEM dicts. |
| 243 | oem_props: A list of OEM properties that should be read from OEM dicts; None |
| 244 | if the build doesn't use any OEM-specific property. |
| 245 | fingerprint: The fingerprint of the build, which would be calculated based |
| 246 | on OEM properties if applicable. |
| 247 | device: The device name, which could come from OEM dicts if applicable. |
| 248 | """ |
| 249 | |
| 250 | def __init__(self, info_dict, oem_dicts): |
| 251 | """Initializes a BuildInfo instance with the given dicts. |
| 252 | |
Tao Bao | 667c753 | 2018-07-06 10:13:59 -0700 | [diff] [blame] | 253 | Note that it only wraps up the given dicts, without making copies. |
| 254 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 255 | Arguments: |
| 256 | info_dict: The build-time info dict. |
| 257 | oem_dicts: A list of OEM dicts (which is parsed from --oem_settings). Note |
| 258 | that it always uses the first dict to calculate the fingerprint or the |
| 259 | device name. The rest would be used for asserting OEM properties only |
Tao Bao | 667c753 | 2018-07-06 10:13:59 -0700 | [diff] [blame] | 260 | (e.g. one package can be installed on one of these devices). |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 261 | """ |
| 262 | self.info_dict = info_dict |
| 263 | self.oem_dicts = oem_dicts |
| 264 | |
| 265 | self._is_ab = info_dict.get("ab_update") == "true" |
| 266 | self._oem_props = info_dict.get("oem_fingerprint_properties") |
| 267 | |
| 268 | if self._oem_props: |
| 269 | assert oem_dicts, "OEM source required for this build" |
| 270 | |
| 271 | # These two should be computed only after setting self._oem_props. |
| 272 | self._device = self.GetOemProperty("ro.product.device") |
| 273 | self._fingerprint = self.CalculateFingerprint() |
| 274 | |
| 275 | @property |
| 276 | def is_ab(self): |
| 277 | return self._is_ab |
| 278 | |
| 279 | @property |
| 280 | def device(self): |
| 281 | return self._device |
| 282 | |
| 283 | @property |
| 284 | def fingerprint(self): |
| 285 | return self._fingerprint |
| 286 | |
| 287 | @property |
| 288 | def oem_props(self): |
| 289 | return self._oem_props |
| 290 | |
| 291 | def __getitem__(self, key): |
| 292 | return self.info_dict[key] |
| 293 | |
Tao Bao | 667c753 | 2018-07-06 10:13:59 -0700 | [diff] [blame] | 294 | def __setitem__(self, key, value): |
| 295 | self.info_dict[key] = value |
| 296 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 297 | def get(self, key, default=None): |
| 298 | return self.info_dict.get(key, default) |
| 299 | |
Tao Bao | 667c753 | 2018-07-06 10:13:59 -0700 | [diff] [blame] | 300 | def items(self): |
| 301 | return self.info_dict.items() |
| 302 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 303 | def GetBuildProp(self, prop): |
| 304 | """Returns the inquired build property.""" |
| 305 | try: |
| 306 | return self.info_dict.get("build.prop", {})[prop] |
| 307 | except KeyError: |
| 308 | raise common.ExternalError("couldn't find %s in build.prop" % (prop,)) |
| 309 | |
| 310 | def GetVendorBuildProp(self, prop): |
| 311 | """Returns the inquired vendor build property.""" |
| 312 | try: |
| 313 | return self.info_dict.get("vendor.build.prop", {})[prop] |
| 314 | except KeyError: |
| 315 | raise common.ExternalError( |
| 316 | "couldn't find %s in vendor.build.prop" % (prop,)) |
| 317 | |
| 318 | def GetOemProperty(self, key): |
| 319 | if self.oem_props is not None and key in self.oem_props: |
| 320 | return self.oem_dicts[0][key] |
| 321 | return self.GetBuildProp(key) |
| 322 | |
| 323 | def CalculateFingerprint(self): |
| 324 | if self.oem_props is None: |
| 325 | return self.GetBuildProp("ro.build.fingerprint") |
| 326 | return "%s/%s/%s:%s" % ( |
| 327 | self.GetOemProperty("ro.product.brand"), |
| 328 | self.GetOemProperty("ro.product.name"), |
| 329 | self.GetOemProperty("ro.product.device"), |
| 330 | self.GetBuildProp("ro.build.thumbprint")) |
| 331 | |
| 332 | def WriteMountOemScript(self, script): |
| 333 | assert self.oem_props is not None |
| 334 | recovery_mount_options = self.info_dict.get("recovery_mount_options") |
| 335 | script.Mount("/oem", recovery_mount_options) |
| 336 | |
| 337 | def WriteDeviceAssertions(self, script, oem_no_mount): |
| 338 | # Read the property directly if not using OEM properties. |
| 339 | if not self.oem_props: |
| 340 | script.AssertDevice(self.device) |
| 341 | return |
| 342 | |
| 343 | # Otherwise assert OEM properties. |
| 344 | if not self.oem_dicts: |
| 345 | raise common.ExternalError( |
| 346 | "No OEM file provided to answer expected assertions") |
| 347 | |
| 348 | for prop in self.oem_props.split(): |
| 349 | values = [] |
| 350 | for oem_dict in self.oem_dicts: |
| 351 | if prop in oem_dict: |
| 352 | values.append(oem_dict[prop]) |
| 353 | if not values: |
| 354 | raise common.ExternalError( |
| 355 | "The OEM file is missing the property %s" % (prop,)) |
| 356 | script.AssertOemProperty(prop, values, oem_no_mount) |
| 357 | |
| 358 | |
Tao Bao | fabe083 | 2018-01-17 15:52:28 -0800 | [diff] [blame] | 359 | class PayloadSigner(object): |
| 360 | """A class that wraps the payload signing works. |
| 361 | |
| 362 | When generating a Payload, hashes of the payload and metadata files will be |
| 363 | signed with the device key, either by calling an external payload signer or |
| 364 | by calling openssl with the package key. This class provides a unified |
| 365 | interface, so that callers can just call PayloadSigner.Sign(). |
| 366 | |
| 367 | If an external payload signer has been specified (OPTIONS.payload_signer), it |
| 368 | calls the signer with the provided args (OPTIONS.payload_signer_args). Note |
| 369 | that the signing key should be provided as part of the payload_signer_args. |
| 370 | Otherwise without an external signer, it uses the package key |
| 371 | (OPTIONS.package_key) and calls openssl for the signing works. |
| 372 | """ |
| 373 | |
| 374 | def __init__(self): |
| 375 | if OPTIONS.payload_signer is None: |
| 376 | # Prepare the payload signing key. |
| 377 | private_key = OPTIONS.package_key + OPTIONS.private_key_suffix |
| 378 | pw = OPTIONS.key_passwords[OPTIONS.package_key] |
| 379 | |
| 380 | cmd = ["openssl", "pkcs8", "-in", private_key, "-inform", "DER"] |
| 381 | cmd.extend(["-passin", "pass:" + pw] if pw else ["-nocrypt"]) |
| 382 | signing_key = common.MakeTempFile(prefix="key-", suffix=".key") |
| 383 | cmd.extend(["-out", signing_key]) |
| 384 | |
| 385 | get_signing_key = common.Run(cmd, verbose=False, stdout=subprocess.PIPE, |
| 386 | stderr=subprocess.STDOUT) |
| 387 | stdoutdata, _ = get_signing_key.communicate() |
| 388 | assert get_signing_key.returncode == 0, \ |
| 389 | "Failed to get signing key: {}".format(stdoutdata) |
| 390 | |
| 391 | self.signer = "openssl" |
| 392 | self.signer_args = ["pkeyutl", "-sign", "-inkey", signing_key, |
| 393 | "-pkeyopt", "digest:sha256"] |
| 394 | else: |
| 395 | self.signer = OPTIONS.payload_signer |
| 396 | self.signer_args = OPTIONS.payload_signer_args |
| 397 | |
| 398 | def Sign(self, in_file): |
| 399 | """Signs the given input file. Returns the output filename.""" |
| 400 | out_file = common.MakeTempFile(prefix="signed-", suffix=".bin") |
| 401 | cmd = [self.signer] + self.signer_args + ['-in', in_file, '-out', out_file] |
| 402 | signing = common.Run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| 403 | stdoutdata, _ = signing.communicate() |
| 404 | assert signing.returncode == 0, \ |
| 405 | "Failed to sign the input file: {}".format(stdoutdata) |
| 406 | return out_file |
| 407 | |
| 408 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 409 | class Payload(object): |
| 410 | """Manages the creation and the signing of an A/B OTA Payload.""" |
| 411 | |
| 412 | PAYLOAD_BIN = 'payload.bin' |
| 413 | PAYLOAD_PROPERTIES_TXT = 'payload_properties.txt' |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 414 | SECONDARY_PAYLOAD_BIN = 'secondary/payload.bin' |
| 415 | SECONDARY_PAYLOAD_PROPERTIES_TXT = 'secondary/payload_properties.txt' |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 416 | |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 417 | def __init__(self, secondary=False): |
| 418 | """Initializes a Payload instance. |
| 419 | |
| 420 | Args: |
| 421 | secondary: Whether it's generating a secondary payload (default: False). |
| 422 | """ |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 423 | # The place where the output from the subprocess should go. |
| 424 | self._log_file = sys.stdout if OPTIONS.verbose else subprocess.PIPE |
| 425 | self.payload_file = None |
| 426 | self.payload_properties = None |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 427 | self.secondary = secondary |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 428 | |
| 429 | def Generate(self, target_file, source_file=None, additional_args=None): |
| 430 | """Generates a payload from the given target-files zip(s). |
| 431 | |
| 432 | Args: |
| 433 | target_file: The filename of the target build target-files zip. |
| 434 | source_file: The filename of the source build target-files zip; or None if |
| 435 | generating a full OTA. |
| 436 | additional_args: A list of additional args that should be passed to |
| 437 | brillo_update_payload script; or None. |
| 438 | """ |
| 439 | if additional_args is None: |
| 440 | additional_args = [] |
| 441 | |
| 442 | payload_file = common.MakeTempFile(prefix="payload-", suffix=".bin") |
| 443 | cmd = ["brillo_update_payload", "generate", |
| 444 | "--payload", payload_file, |
| 445 | "--target_image", target_file] |
| 446 | if source_file is not None: |
| 447 | cmd.extend(["--source_image", source_file]) |
| 448 | cmd.extend(additional_args) |
| 449 | p = common.Run(cmd, stdout=self._log_file, stderr=subprocess.STDOUT) |
| 450 | stdoutdata, _ = p.communicate() |
| 451 | assert p.returncode == 0, \ |
| 452 | "brillo_update_payload generate failed: {}".format(stdoutdata) |
| 453 | |
| 454 | self.payload_file = payload_file |
| 455 | self.payload_properties = None |
| 456 | |
| 457 | def Sign(self, payload_signer): |
| 458 | """Generates and signs the hashes of the payload and metadata. |
| 459 | |
| 460 | Args: |
| 461 | payload_signer: A PayloadSigner() instance that serves the signing work. |
| 462 | |
| 463 | Raises: |
| 464 | AssertionError: On any failure when calling brillo_update_payload script. |
| 465 | """ |
| 466 | assert isinstance(payload_signer, PayloadSigner) |
| 467 | |
| 468 | # 1. Generate hashes of the payload and metadata files. |
| 469 | payload_sig_file = common.MakeTempFile(prefix="sig-", suffix=".bin") |
| 470 | metadata_sig_file = common.MakeTempFile(prefix="sig-", suffix=".bin") |
| 471 | cmd = ["brillo_update_payload", "hash", |
| 472 | "--unsigned_payload", self.payload_file, |
| 473 | "--signature_size", "256", |
| 474 | "--metadata_hash_file", metadata_sig_file, |
| 475 | "--payload_hash_file", payload_sig_file] |
| 476 | p1 = common.Run(cmd, stdout=self._log_file, stderr=subprocess.STDOUT) |
| 477 | p1.communicate() |
| 478 | assert p1.returncode == 0, "brillo_update_payload hash failed" |
| 479 | |
| 480 | # 2. Sign the hashes. |
| 481 | signed_payload_sig_file = payload_signer.Sign(payload_sig_file) |
| 482 | signed_metadata_sig_file = payload_signer.Sign(metadata_sig_file) |
| 483 | |
| 484 | # 3. Insert the signatures back into the payload file. |
| 485 | signed_payload_file = common.MakeTempFile(prefix="signed-payload-", |
| 486 | suffix=".bin") |
| 487 | cmd = ["brillo_update_payload", "sign", |
| 488 | "--unsigned_payload", self.payload_file, |
| 489 | "--payload", signed_payload_file, |
| 490 | "--signature_size", "256", |
| 491 | "--metadata_signature_file", signed_metadata_sig_file, |
| 492 | "--payload_signature_file", signed_payload_sig_file] |
| 493 | p1 = common.Run(cmd, stdout=self._log_file, stderr=subprocess.STDOUT) |
| 494 | p1.communicate() |
| 495 | assert p1.returncode == 0, "brillo_update_payload sign failed" |
| 496 | |
| 497 | # 4. Dump the signed payload properties. |
| 498 | properties_file = common.MakeTempFile(prefix="payload-properties-", |
| 499 | suffix=".txt") |
| 500 | cmd = ["brillo_update_payload", "properties", |
| 501 | "--payload", signed_payload_file, |
| 502 | "--properties_file", properties_file] |
| 503 | p1 = common.Run(cmd, stdout=self._log_file, stderr=subprocess.STDOUT) |
| 504 | p1.communicate() |
| 505 | assert p1.returncode == 0, "brillo_update_payload properties failed" |
| 506 | |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 507 | if self.secondary: |
| 508 | with open(properties_file, "a") as f: |
| 509 | f.write("SWITCH_SLOT_ON_REBOOT=0\n") |
| 510 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 511 | if OPTIONS.wipe_user_data: |
| 512 | with open(properties_file, "a") as f: |
| 513 | f.write("POWERWASH=1\n") |
| 514 | |
| 515 | self.payload_file = signed_payload_file |
| 516 | self.payload_properties = properties_file |
| 517 | |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 518 | def WriteToZip(self, output_zip): |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 519 | """Writes the payload to the given zip. |
| 520 | |
| 521 | Args: |
| 522 | output_zip: The output ZipFile instance. |
| 523 | """ |
| 524 | assert self.payload_file is not None |
| 525 | assert self.payload_properties is not None |
| 526 | |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 527 | if self.secondary: |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 528 | payload_arcname = Payload.SECONDARY_PAYLOAD_BIN |
| 529 | payload_properties_arcname = Payload.SECONDARY_PAYLOAD_PROPERTIES_TXT |
| 530 | else: |
| 531 | payload_arcname = Payload.PAYLOAD_BIN |
| 532 | payload_properties_arcname = Payload.PAYLOAD_PROPERTIES_TXT |
| 533 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 534 | # Add the signed payload file and properties into the zip. In order to |
| 535 | # support streaming, we pack them as ZIP_STORED. So these entries can be |
| 536 | # read directly with the offset and length pairs. |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 537 | common.ZipWrite(output_zip, self.payload_file, arcname=payload_arcname, |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 538 | compress_type=zipfile.ZIP_STORED) |
| 539 | common.ZipWrite(output_zip, self.payload_properties, |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 540 | arcname=payload_properties_arcname, |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 541 | compress_type=zipfile.ZIP_STORED) |
| 542 | |
| 543 | |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 544 | def SignOutput(temp_zip_name, output_zip_name): |
Christian Oder | f63e2cd | 2017-05-01 22:30:15 +0200 | [diff] [blame] | 545 | pw = OPTIONS.key_passwords[OPTIONS.package_key] |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 546 | |
Doug Zongker | 951495f | 2009-08-14 12:44:19 -0700 | [diff] [blame] | 547 | common.SignFile(temp_zip_name, output_zip_name, OPTIONS.package_key, pw, |
| 548 | whole_file=True) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 549 | |
| 550 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 551 | def _LoadOemDicts(oem_source): |
Alain Vongsouvanh | 7f804ba | 2017-02-16 13:06:55 -0800 | [diff] [blame] | 552 | """Returns the list of loaded OEM properties dict.""" |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 553 | if not oem_source: |
| 554 | return None |
| 555 | |
Alain Vongsouvanh | 7f804ba | 2017-02-16 13:06:55 -0800 | [diff] [blame] | 556 | oem_dicts = [] |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 557 | for oem_file in oem_source: |
| 558 | with open(oem_file) as fp: |
| 559 | oem_dicts.append(common.LoadDictionaryFromLines(fp.readlines())) |
Alain Vongsouvanh | 7f804ba | 2017-02-16 13:06:55 -0800 | [diff] [blame] | 560 | return oem_dicts |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 561 | |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 562 | |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 563 | def _WriteRecoveryImageToBoot(script, output_zip): |
| 564 | """Find and write recovery image to /boot in two-step OTA. |
| 565 | |
| 566 | In two-step OTAs, we write recovery image to /boot as the first step so that |
| 567 | we can reboot to there and install a new recovery image to /recovery. |
| 568 | A special "recovery-two-step.img" will be preferred, which encodes the correct |
| 569 | path of "/boot". Otherwise the device may show "device is corrupt" message |
| 570 | when booting into /boot. |
| 571 | |
| 572 | Fall back to using the regular recovery.img if the two-step recovery image |
| 573 | doesn't exist. Note that rebuilding the special image at this point may be |
| 574 | infeasible, because we don't have the desired boot signer and keys when |
| 575 | calling ota_from_target_files.py. |
| 576 | """ |
| 577 | |
| 578 | recovery_two_step_img_name = "recovery-two-step.img" |
| 579 | recovery_two_step_img_path = os.path.join( |
| 580 | OPTIONS.input_tmp, "IMAGES", recovery_two_step_img_name) |
| 581 | if os.path.exists(recovery_two_step_img_path): |
| 582 | recovery_two_step_img = common.GetBootableImage( |
| 583 | recovery_two_step_img_name, recovery_two_step_img_name, |
| 584 | OPTIONS.input_tmp, "RECOVERY") |
| 585 | common.ZipWriteStr( |
| 586 | output_zip, recovery_two_step_img_name, recovery_two_step_img.data) |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 587 | print("two-step package: using %s in stage 1/3" % ( |
| 588 | recovery_two_step_img_name,)) |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 589 | script.WriteRawImage("/boot", recovery_two_step_img_name) |
| 590 | else: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 591 | print("two-step package: using recovery.img in stage 1/3") |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 592 | # The "recovery.img" entry has been written into package earlier. |
| 593 | script.WriteRawImage("/boot", "recovery.img") |
| 594 | |
| 595 | |
Doug Zongker | c925382 | 2014-02-04 12:17:58 -0800 | [diff] [blame] | 596 | def HasRecoveryPatch(target_files_zip): |
Tao Bao | f2cffbd | 2015-07-22 12:33:18 -0700 | [diff] [blame] | 597 | namelist = [name for name in target_files_zip.namelist()] |
| 598 | return ("SYSTEM/recovery-from-boot.p" in namelist or |
| 599 | "SYSTEM/etc/recovery.img" in namelist) |
Doug Zongker | 73ef825 | 2009-07-23 15:12:53 -0700 | [diff] [blame] | 600 | |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 601 | |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 602 | def HasVendorPartition(target_files_zip): |
| 603 | try: |
| 604 | target_files_zip.getinfo("VENDOR/") |
| 605 | return True |
| 606 | except KeyError: |
| 607 | return False |
| 608 | |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 609 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 610 | def HasTrebleEnabled(target_files_zip, target_info): |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 611 | return (HasVendorPartition(target_files_zip) and |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 612 | target_info.GetBuildProp("ro.treble.enabled") == "true") |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 613 | |
| 614 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 615 | def WriteFingerprintAssertion(script, target_info, source_info): |
| 616 | source_oem_props = source_info.oem_props |
| 617 | target_oem_props = target_info.oem_props |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 618 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 619 | if source_oem_props is None and target_oem_props is None: |
| 620 | script.AssertSomeFingerprint( |
| 621 | source_info.fingerprint, target_info.fingerprint) |
| 622 | elif source_oem_props is not None and target_oem_props is not None: |
| 623 | script.AssertSomeThumbprint( |
| 624 | target_info.GetBuildProp("ro.build.thumbprint"), |
| 625 | source_info.GetBuildProp("ro.build.thumbprint")) |
| 626 | elif source_oem_props is None and target_oem_props is not None: |
| 627 | script.AssertFingerprintOrThumbprint( |
| 628 | source_info.fingerprint, |
| 629 | target_info.GetBuildProp("ro.build.thumbprint")) |
| 630 | else: |
| 631 | script.AssertFingerprintOrThumbprint( |
| 632 | target_info.fingerprint, |
| 633 | source_info.GetBuildProp("ro.build.thumbprint")) |
Doug Zongker | 73ef825 | 2009-07-23 15:12:53 -0700 | [diff] [blame] | 634 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 635 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 636 | def AddCompatibilityArchiveIfTrebleEnabled(target_zip, output_zip, target_info, |
| 637 | source_info=None): |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 638 | """Adds compatibility info into the output zip if it's Treble-enabled target. |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 639 | |
| 640 | Metadata used for on-device compatibility verification is retrieved from |
| 641 | target_zip then added to compatibility.zip which is added to the output_zip |
| 642 | archive. |
| 643 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 644 | Compatibility archive should only be included for devices that have enabled |
| 645 | Treble support. |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 646 | |
| 647 | Args: |
| 648 | target_zip: Zip file containing the source files to be included for OTA. |
| 649 | output_zip: Zip file that will be sent for OTA. |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 650 | target_info: The BuildInfo instance that holds the target build info. |
| 651 | source_info: The BuildInfo instance that holds the source build info, if |
| 652 | generating an incremental OTA; None otherwise. |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 653 | """ |
| 654 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 655 | def AddCompatibilityArchive(system_updated, vendor_updated): |
| 656 | """Adds compatibility info based on system/vendor update status. |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 657 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 658 | Args: |
| 659 | system_updated: If True, the system image will be updated and therefore |
| 660 | its metadata should be included. |
| 661 | vendor_updated: If True, the vendor image will be updated and therefore |
| 662 | its metadata should be included. |
| 663 | """ |
| 664 | # Determine what metadata we need. Files are names relative to META/. |
| 665 | compatibility_files = [] |
| 666 | vendor_metadata = ("vendor_manifest.xml", "vendor_matrix.xml") |
| 667 | system_metadata = ("system_manifest.xml", "system_matrix.xml") |
| 668 | if vendor_updated: |
| 669 | compatibility_files += vendor_metadata |
| 670 | if system_updated: |
| 671 | compatibility_files += system_metadata |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 672 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 673 | # Create new archive. |
| 674 | compatibility_archive = tempfile.NamedTemporaryFile() |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 675 | compatibility_archive_zip = zipfile.ZipFile( |
| 676 | compatibility_archive, "w", compression=zipfile.ZIP_DEFLATED) |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 677 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 678 | # Add metadata. |
| 679 | for file_name in compatibility_files: |
| 680 | target_file_name = "META/" + file_name |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 681 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 682 | if target_file_name in target_zip.namelist(): |
| 683 | data = target_zip.read(target_file_name) |
| 684 | common.ZipWriteStr(compatibility_archive_zip, file_name, data) |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 685 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 686 | # Ensure files are written before we copy into output_zip. |
| 687 | compatibility_archive_zip.close() |
| 688 | |
| 689 | # Only add the archive if we have any compatibility info. |
| 690 | if compatibility_archive_zip.namelist(): |
| 691 | common.ZipWrite(output_zip, compatibility_archive.name, |
| 692 | arcname="compatibility.zip", |
| 693 | compress_type=zipfile.ZIP_STORED) |
| 694 | |
| 695 | # Will only proceed if the target has enabled the Treble support (as well as |
| 696 | # having a /vendor partition). |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 697 | if not HasTrebleEnabled(target_zip, target_info): |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 698 | return |
| 699 | |
| 700 | # We don't support OEM thumbprint in Treble world (which calculates |
| 701 | # fingerprints in a different way as shown in CalculateFingerprint()). |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 702 | assert not target_info.oem_props |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 703 | |
| 704 | # Full OTA carries the info for system/vendor both. |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 705 | if source_info is None: |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 706 | AddCompatibilityArchive(True, True) |
| 707 | return |
| 708 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 709 | assert not source_info.oem_props |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 710 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 711 | source_fp = source_info.fingerprint |
| 712 | target_fp = target_info.fingerprint |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 713 | system_updated = source_fp != target_fp |
| 714 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 715 | source_fp_vendor = source_info.GetVendorBuildProp( |
| 716 | "ro.vendor.build.fingerprint") |
| 717 | target_fp_vendor = target_info.GetVendorBuildProp( |
| 718 | "ro.vendor.build.fingerprint") |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 719 | vendor_updated = source_fp_vendor != target_fp_vendor |
| 720 | |
| 721 | AddCompatibilityArchive(system_updated, vendor_updated) |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 722 | |
| 723 | |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 724 | def WriteFullOTAPackage(input_zip, output_file): |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 725 | target_info = BuildInfo(OPTIONS.info_dict, OPTIONS.oem_dicts) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 726 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 727 | # We don't know what version it will be installed on top of. We expect the API |
| 728 | # just won't change very often. Similarly for fstab, it might have changed in |
| 729 | # the target build. |
| 730 | target_api_version = target_info["recovery_api_version"] |
| 731 | script = edify_generator.EdifyGenerator(target_api_version, target_info) |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 732 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 733 | if target_info.oem_props and not OPTIONS.oem_no_mount: |
| 734 | target_info.WriteMountOemScript(script) |
| 735 | |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 736 | metadata = GetPackageMetadata(target_info) |
Doug Zongker | 2ea2106 | 2010-04-28 16:05:21 -0700 | [diff] [blame] | 737 | |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 738 | if not OPTIONS.no_signing: |
| 739 | staging_file = common.MakeTempFile(suffix='.zip') |
| 740 | else: |
| 741 | staging_file = output_file |
| 742 | |
| 743 | output_zip = zipfile.ZipFile( |
| 744 | staging_file, "w", compression=zipfile.ZIP_DEFLATED) |
| 745 | |
Doug Zongker | 05d3dea | 2009-06-22 11:32:31 -0700 | [diff] [blame] | 746 | device_specific = common.DeviceSpecificParams( |
| 747 | input_zip=input_zip, |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 748 | input_version=target_api_version, |
Doug Zongker | 05d3dea | 2009-06-22 11:32:31 -0700 | [diff] [blame] | 749 | output_zip=output_zip, |
| 750 | script=script, |
Doug Zongker | 2ea2106 | 2010-04-28 16:05:21 -0700 | [diff] [blame] | 751 | input_tmp=OPTIONS.input_tmp, |
Doug Zongker | 96a57e7 | 2010-09-26 14:57:41 -0700 | [diff] [blame] | 752 | metadata=metadata, |
| 753 | info_dict=OPTIONS.info_dict) |
Doug Zongker | 05d3dea | 2009-06-22 11:32:31 -0700 | [diff] [blame] | 754 | |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 755 | assert HasRecoveryPatch(input_zip) |
Doug Zongker | c925382 | 2014-02-04 12:17:58 -0800 | [diff] [blame] | 756 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 757 | # Assertions (e.g. downgrade check, device properties check). |
| 758 | ts = target_info.GetBuildProp("ro.build.date.utc") |
| 759 | ts_text = target_info.GetBuildProp("ro.build.date") |
Elliott Hughes | d8a52f9 | 2016-06-20 14:35:47 -0700 | [diff] [blame] | 760 | script.AssertOlderBuild(ts, ts_text) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 761 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 762 | target_info.WriteDeviceAssertions(script, OPTIONS.oem_no_mount) |
Doug Zongker | 05d3dea | 2009-06-22 11:32:31 -0700 | [diff] [blame] | 763 | device_specific.FullOTA_Assertions() |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 764 | |
| 765 | # Two-step package strategy (in chronological order, which is *not* |
| 766 | # the order in which the generated script has things): |
| 767 | # |
| 768 | # if stage is not "2/3" or "3/3": |
| 769 | # write recovery image to boot partition |
| 770 | # set stage to "2/3" |
| 771 | # reboot to boot partition and restart recovery |
| 772 | # else if stage is "2/3": |
| 773 | # write recovery image to recovery partition |
| 774 | # set stage to "3/3" |
| 775 | # reboot to recovery partition and restart recovery |
| 776 | # else: |
| 777 | # (stage must be "3/3") |
| 778 | # set stage to "" |
| 779 | # do normal full package installation: |
| 780 | # wipe and install system, boot image, etc. |
| 781 | # set up system to update recovery partition on first boot |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 782 | # complete script normally |
| 783 | # (allow recovery to mark itself finished and reboot) |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 784 | |
| 785 | recovery_img = common.GetBootableImage("recovery.img", "recovery.img", |
| 786 | OPTIONS.input_tmp, "RECOVERY") |
| 787 | if OPTIONS.two_step: |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 788 | if not target_info.get("multistage_support"): |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 789 | assert False, "two-step packages not supported by this build" |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 790 | fs = target_info["fstab"]["/misc"] |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 791 | assert fs.fs_type.upper() == "EMMC", \ |
| 792 | "two-step packages only supported on devices with EMMC /misc partitions" |
| 793 | bcb_dev = {"bcb_dev": fs.device} |
| 794 | common.ZipWriteStr(output_zip, "recovery.img", recovery_img.data) |
| 795 | script.AppendExtra(""" |
Michael Runge | fb8886d | 2014-10-23 13:51:04 -0700 | [diff] [blame] | 796 | if get_stage("%(bcb_dev)s") == "2/3" then |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 797 | """ % bcb_dev) |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 798 | |
| 799 | # Stage 2/3: Write recovery image to /recovery (currently running /boot). |
| 800 | script.Comment("Stage 2/3") |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 801 | script.WriteRawImage("/recovery", "recovery.img") |
| 802 | script.AppendExtra(""" |
| 803 | set_stage("%(bcb_dev)s", "3/3"); |
| 804 | reboot_now("%(bcb_dev)s", "recovery"); |
Michael Runge | fb8886d | 2014-10-23 13:51:04 -0700 | [diff] [blame] | 805 | else if get_stage("%(bcb_dev)s") == "3/3" then |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 806 | """ % bcb_dev) |
| 807 | |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 808 | # Stage 3/3: Make changes. |
| 809 | script.Comment("Stage 3/3") |
| 810 | |
Tao Bao | 6c55a8a | 2015-04-08 15:30:27 -0700 | [diff] [blame] | 811 | # Dump fingerprints |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 812 | script.Print("Target: {}".format(target_info.fingerprint)) |
Tao Bao | 6c55a8a | 2015-04-08 15:30:27 -0700 | [diff] [blame] | 813 | |
Doug Zongker | e5ff590 | 2012-01-17 10:55:37 -0800 | [diff] [blame] | 814 | device_specific.FullOTA_InstallBegin() |
Doug Zongker | 171f1cd | 2009-06-15 22:36:37 -0700 | [diff] [blame] | 815 | |
Doug Zongker | 01ce19c | 2014-02-04 13:48:15 -0800 | [diff] [blame] | 816 | system_progress = 0.75 |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 817 | |
Doug Zongker | dbfaae5 | 2009-04-21 17:12:54 -0700 | [diff] [blame] | 818 | if OPTIONS.wipe_user_data: |
Doug Zongker | 01ce19c | 2014-02-04 13:48:15 -0800 | [diff] [blame] | 819 | system_progress -= 0.1 |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 820 | if HasVendorPartition(input_zip): |
| 821 | system_progress -= 0.1 |
Doug Zongker | dbfaae5 | 2009-04-21 17:12:54 -0700 | [diff] [blame] | 822 | |
Doug Zongker | 4b9596f | 2014-06-09 14:15:45 -0700 | [diff] [blame] | 823 | script.ShowProgress(system_progress, 0) |
Jesse Zhao | 75bcea0 | 2015-01-06 10:59:53 -0800 | [diff] [blame] | 824 | |
Tao Bao | e709b09 | 2018-02-07 12:40:00 -0800 | [diff] [blame] | 825 | # See the notes in WriteBlockIncrementalOTAPackage(). |
| 826 | allow_shared_blocks = target_info.get('ext4_share_dup_blocks') == "true" |
| 827 | |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 828 | # Full OTA is done as an "incremental" against an empty source image. This |
| 829 | # has the effect of writing new data from the package to the entire |
| 830 | # partition, but lets us reuse the updater code that writes incrementals to |
| 831 | # do it. |
Tao Bao | e709b09 | 2018-02-07 12:40:00 -0800 | [diff] [blame] | 832 | system_tgt = common.GetSparseImage("system", OPTIONS.input_tmp, input_zip, |
| 833 | allow_shared_blocks) |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 834 | system_tgt.ResetFileMap() |
| 835 | system_diff = common.BlockDifference("system", system_tgt, src=None) |
| 836 | system_diff.WriteScript(script, output_zip) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 837 | |
Tao Bao | 7a5bf8a | 2015-07-21 18:01:20 -0700 | [diff] [blame] | 838 | boot_img = common.GetBootableImage( |
| 839 | "boot.img", "boot.img", OPTIONS.input_tmp, "BOOT") |
Doug Zongker | c925382 | 2014-02-04 12:17:58 -0800 | [diff] [blame] | 840 | |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 841 | if HasVendorPartition(input_zip): |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 842 | script.ShowProgress(0.1, 0) |
| 843 | |
Tao Bao | e709b09 | 2018-02-07 12:40:00 -0800 | [diff] [blame] | 844 | vendor_tgt = common.GetSparseImage("vendor", OPTIONS.input_tmp, input_zip, |
| 845 | allow_shared_blocks) |
Tao Bao | 457cbf6 | 2017-03-06 09:56:01 -0800 | [diff] [blame] | 846 | vendor_tgt.ResetFileMap() |
| 847 | vendor_diff = common.BlockDifference("vendor", vendor_tgt) |
| 848 | vendor_diff.WriteScript(script, output_zip) |
Doug Zongker | 73ef825 | 2009-07-23 15:12:53 -0700 | [diff] [blame] | 849 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 850 | AddCompatibilityArchiveIfTrebleEnabled(input_zip, output_zip, target_info) |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 851 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 852 | common.CheckSize(boot_img.data, "boot.img", target_info) |
Doug Zongker | 73ef825 | 2009-07-23 15:12:53 -0700 | [diff] [blame] | 853 | common.ZipWriteStr(output_zip, "boot.img", boot_img.data) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 854 | |
Doug Zongker | 01ce19c | 2014-02-04 13:48:15 -0800 | [diff] [blame] | 855 | script.ShowProgress(0.05, 5) |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 856 | script.WriteRawImage("/boot", "boot.img") |
Doug Zongker | 05d3dea | 2009-06-22 11:32:31 -0700 | [diff] [blame] | 857 | |
Doug Zongker | 01ce19c | 2014-02-04 13:48:15 -0800 | [diff] [blame] | 858 | script.ShowProgress(0.2, 10) |
Doug Zongker | 05d3dea | 2009-06-22 11:32:31 -0700 | [diff] [blame] | 859 | device_specific.FullOTA_InstallEnd() |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 860 | |
Doug Zongker | 1c390a2 | 2009-05-14 19:06:36 -0700 | [diff] [blame] | 861 | if OPTIONS.extra_script is not None: |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 862 | script.AppendExtra(OPTIONS.extra_script) |
Doug Zongker | 1c390a2 | 2009-05-14 19:06:36 -0700 | [diff] [blame] | 863 | |
Doug Zongker | 1483360 | 2010-02-02 13:12:04 -0800 | [diff] [blame] | 864 | script.UnmountAll() |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 865 | |
Doug Zongker | 922206e | 2014-03-04 13:16:24 -0800 | [diff] [blame] | 866 | if OPTIONS.wipe_user_data: |
| 867 | script.ShowProgress(0.1, 10) |
| 868 | script.FormatPartition("/data") |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 869 | |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 870 | if OPTIONS.two_step: |
| 871 | script.AppendExtra(""" |
| 872 | set_stage("%(bcb_dev)s", ""); |
| 873 | """ % bcb_dev) |
| 874 | script.AppendExtra("else\n") |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 875 | |
| 876 | # Stage 1/3: Nothing to verify for full OTA. Write recovery image to /boot. |
| 877 | script.Comment("Stage 1/3") |
| 878 | _WriteRecoveryImageToBoot(script, output_zip) |
| 879 | |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 880 | script.AppendExtra(""" |
| 881 | set_stage("%(bcb_dev)s", "2/3"); |
| 882 | reboot_now("%(bcb_dev)s", ""); |
| 883 | endif; |
| 884 | endif; |
| 885 | """ % bcb_dev) |
Tao Bao | d8d14be | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 886 | |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 887 | script.SetProgress(1) |
| 888 | script.AddToZip(input_zip, output_zip, input_path=OPTIONS.updater_binary) |
Tao Bao | d8d14be | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 889 | metadata["ota-required-cache"] = str(script.required_cache) |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 890 | |
| 891 | # We haven't written the metadata entry, which will be done in |
| 892 | # FinalizeMetadata. |
| 893 | common.ZipClose(output_zip) |
| 894 | |
| 895 | needed_property_files = ( |
| 896 | NonAbOtaPropertyFiles(), |
| 897 | ) |
| 898 | FinalizeMetadata(metadata, staging_file, output_file, needed_property_files) |
Doug Zongker | 2ea2106 | 2010-04-28 16:05:21 -0700 | [diff] [blame] | 899 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 900 | |
Doug Zongker | 2ea2106 | 2010-04-28 16:05:21 -0700 | [diff] [blame] | 901 | def WriteMetadata(metadata, output_zip): |
Tao Bao | 2dd1c48 | 2017-02-03 16:49:39 -0800 | [diff] [blame] | 902 | value = "".join(["%s=%s\n" % kv for kv in sorted(metadata.iteritems())]) |
| 903 | common.ZipWriteStr(output_zip, METADATA_NAME, value, |
| 904 | compress_type=zipfile.ZIP_STORED) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 905 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 906 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 907 | def HandleDowngradeMetadata(metadata, target_info, source_info): |
Tao Bao | b31892e | 2017-02-07 11:21:17 -0800 | [diff] [blame] | 908 | # Only incremental OTAs are allowed to reach here. |
| 909 | assert OPTIONS.incremental_source is not None |
| 910 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 911 | post_timestamp = target_info.GetBuildProp("ro.build.date.utc") |
| 912 | pre_timestamp = source_info.GetBuildProp("ro.build.date.utc") |
Tao Bao | b31892e | 2017-02-07 11:21:17 -0800 | [diff] [blame] | 913 | is_downgrade = long(post_timestamp) < long(pre_timestamp) |
| 914 | |
| 915 | if OPTIONS.downgrade: |
Tao Bao | b31892e | 2017-02-07 11:21:17 -0800 | [diff] [blame] | 916 | if not is_downgrade: |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 917 | raise RuntimeError( |
| 918 | "--downgrade or --override_timestamp specified but no downgrade " |
| 919 | "detected: pre: %s, post: %s" % (pre_timestamp, post_timestamp)) |
Tao Bao | 3e6161a | 2017-02-28 11:48:48 -0800 | [diff] [blame] | 920 | metadata["ota-downgrade"] = "yes" |
Tao Bao | b31892e | 2017-02-07 11:21:17 -0800 | [diff] [blame] | 921 | else: |
| 922 | if is_downgrade: |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 923 | raise RuntimeError( |
| 924 | "Downgrade detected based on timestamp check: pre: %s, post: %s. " |
| 925 | "Need to specify --override_timestamp OR --downgrade to allow " |
| 926 | "building the incremental." % (pre_timestamp, post_timestamp)) |
Tao Bao | b31892e | 2017-02-07 11:21:17 -0800 | [diff] [blame] | 927 | |
| 928 | |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 929 | def GetPackageMetadata(target_info, source_info=None): |
| 930 | """Generates and returns the metadata dict. |
| 931 | |
| 932 | It generates a dict() that contains the info to be written into an OTA |
| 933 | package (META-INF/com/android/metadata). It also handles the detection of |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 934 | downgrade / data wipe based on the global options. |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 935 | |
| 936 | Args: |
| 937 | target_info: The BuildInfo instance that holds the target build info. |
| 938 | source_info: The BuildInfo instance that holds the source build info, or |
| 939 | None if generating full OTA. |
| 940 | |
| 941 | Returns: |
| 942 | A dict to be written into package metadata entry. |
| 943 | """ |
| 944 | assert isinstance(target_info, BuildInfo) |
| 945 | assert source_info is None or isinstance(source_info, BuildInfo) |
| 946 | |
| 947 | metadata = { |
| 948 | 'post-build' : target_info.fingerprint, |
| 949 | 'post-build-incremental' : target_info.GetBuildProp( |
| 950 | 'ro.build.version.incremental'), |
Tao Bao | 35dc255 | 2018-02-01 13:18:00 -0800 | [diff] [blame] | 951 | 'post-sdk-level' : target_info.GetBuildProp( |
| 952 | 'ro.build.version.sdk'), |
| 953 | 'post-security-patch-level' : target_info.GetBuildProp( |
| 954 | 'ro.build.version.security_patch'), |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 955 | } |
| 956 | |
| 957 | if target_info.is_ab: |
| 958 | metadata['ota-type'] = 'AB' |
| 959 | metadata['ota-required-cache'] = '0' |
| 960 | else: |
| 961 | metadata['ota-type'] = 'BLOCK' |
| 962 | |
| 963 | if OPTIONS.wipe_user_data: |
| 964 | metadata['ota-wipe'] = 'yes' |
| 965 | |
| 966 | is_incremental = source_info is not None |
| 967 | if is_incremental: |
| 968 | metadata['pre-build'] = source_info.fingerprint |
| 969 | metadata['pre-build-incremental'] = source_info.GetBuildProp( |
| 970 | 'ro.build.version.incremental') |
| 971 | metadata['pre-device'] = source_info.device |
| 972 | else: |
| 973 | metadata['pre-device'] = target_info.device |
| 974 | |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 975 | # Use the actual post-timestamp, even for a downgrade case. |
| 976 | metadata['post-timestamp'] = target_info.GetBuildProp('ro.build.date.utc') |
| 977 | |
| 978 | # Detect downgrades and set up downgrade flags accordingly. |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 979 | if is_incremental: |
| 980 | HandleDowngradeMetadata(metadata, target_info, source_info) |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 981 | |
| 982 | return metadata |
| 983 | |
| 984 | |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 985 | class PropertyFiles(object): |
| 986 | """A class that computes the property-files string for an OTA package. |
| 987 | |
| 988 | A property-files string is a comma-separated string that contains the |
| 989 | offset/size info for an OTA package. The entries, which must be ZIP_STORED, |
| 990 | can be fetched directly with the package URL along with the offset/size info. |
| 991 | These strings can be used for streaming A/B OTAs, or allowing an updater to |
| 992 | download package metadata entry directly, without paying the cost of |
| 993 | downloading entire package. |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 994 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 995 | Computing the final property-files string requires two passes. Because doing |
| 996 | the whole package signing (with signapk.jar) will possibly reorder the ZIP |
| 997 | entries, which may in turn invalidate earlier computed ZIP entry offset/size |
| 998 | values. |
| 999 | |
| 1000 | This class provides functions to be called for each pass. The general flow is |
| 1001 | as follows. |
| 1002 | |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1003 | property_files = PropertyFiles() |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1004 | # The first pass, which writes placeholders before doing initial signing. |
| 1005 | property_files.Compute() |
| 1006 | SignOutput() |
| 1007 | |
| 1008 | # The second pass, by replacing the placeholders with actual data. |
| 1009 | property_files.Finalize() |
| 1010 | SignOutput() |
| 1011 | |
| 1012 | And the caller can additionally verify the final result. |
| 1013 | |
| 1014 | property_files.Verify() |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1015 | """ |
| 1016 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1017 | def __init__(self): |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1018 | self.name = None |
| 1019 | self.required = () |
| 1020 | self.optional = () |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1021 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1022 | def Compute(self, input_zip): |
| 1023 | """Computes and returns a property-files string with placeholders. |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1024 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1025 | We reserve extra space for the offset and size of the metadata entry itself, |
| 1026 | although we don't know the final values until the package gets signed. |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1027 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1028 | Args: |
| 1029 | input_zip: The input ZIP file. |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1030 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1031 | Returns: |
| 1032 | A string with placeholders for the metadata offset/size info, e.g. |
| 1033 | "payload.bin:679:343,payload_properties.txt:378:45,metadata: ". |
| 1034 | """ |
Zhomart Mukhamejanov | 603655f | 2018-05-04 12:35:09 -0700 | [diff] [blame] | 1035 | return self.GetPropertyFilesString(input_zip, reserve_space=True) |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1036 | |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1037 | class InsufficientSpaceException(Exception): |
| 1038 | pass |
| 1039 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1040 | def Finalize(self, input_zip, reserved_length): |
| 1041 | """Finalizes a property-files string with actual METADATA offset/size info. |
| 1042 | |
| 1043 | The input ZIP file has been signed, with the ZIP entries in the desired |
| 1044 | place (signapk.jar will possibly reorder the ZIP entries). Now we compute |
| 1045 | the ZIP entry offsets and construct the property-files string with actual |
| 1046 | data. Note that during this process, we must pad the property-files string |
| 1047 | to the reserved length, so that the METADATA entry size remains the same. |
| 1048 | Otherwise the entries' offsets and sizes may change again. |
| 1049 | |
| 1050 | Args: |
| 1051 | input_zip: The input ZIP file. |
| 1052 | reserved_length: The reserved length of the property-files string during |
| 1053 | the call to Compute(). The final string must be no more than this |
| 1054 | size. |
| 1055 | |
| 1056 | Returns: |
| 1057 | A property-files string including the metadata offset/size info, e.g. |
| 1058 | "payload.bin:679:343,payload_properties.txt:378:45,metadata:69:379 ". |
| 1059 | |
| 1060 | Raises: |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1061 | InsufficientSpaceException: If the reserved length is insufficient to hold |
| 1062 | the final string. |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1063 | """ |
Zhomart Mukhamejanov | 603655f | 2018-05-04 12:35:09 -0700 | [diff] [blame] | 1064 | result = self.GetPropertyFilesString(input_zip, reserve_space=False) |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1065 | if len(result) > reserved_length: |
| 1066 | raise self.InsufficientSpaceException( |
| 1067 | 'Insufficient reserved space: reserved={}, actual={}'.format( |
| 1068 | reserved_length, len(result))) |
| 1069 | |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1070 | result += ' ' * (reserved_length - len(result)) |
| 1071 | return result |
| 1072 | |
| 1073 | def Verify(self, input_zip, expected): |
| 1074 | """Verifies the input ZIP file contains the expected property-files string. |
| 1075 | |
| 1076 | Args: |
| 1077 | input_zip: The input ZIP file. |
| 1078 | expected: The property-files string that's computed from Finalize(). |
| 1079 | |
| 1080 | Raises: |
| 1081 | AssertionError: On finding a mismatch. |
| 1082 | """ |
Zhomart Mukhamejanov | 603655f | 2018-05-04 12:35:09 -0700 | [diff] [blame] | 1083 | actual = self.GetPropertyFilesString(input_zip) |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1084 | assert actual == expected, \ |
| 1085 | "Mismatching streaming metadata: {} vs {}.".format(actual, expected) |
| 1086 | |
Zhomart Mukhamejanov | 603655f | 2018-05-04 12:35:09 -0700 | [diff] [blame] | 1087 | def GetPropertyFilesString(self, zip_file, reserve_space=False): |
| 1088 | """ |
| 1089 | Constructs the property-files string per request. |
| 1090 | |
| 1091 | Args: |
| 1092 | zip_file: The input ZIP file. |
| 1093 | reserved_length: The reserved length of the property-files string. |
| 1094 | |
| 1095 | Returns: |
| 1096 | A property-files string including the metadata offset/size info, e.g. |
| 1097 | "payload.bin:679:343,payload_properties.txt:378:45,metadata: ". |
| 1098 | """ |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1099 | |
| 1100 | def ComputeEntryOffsetSize(name): |
| 1101 | """Computes the zip entry offset and size.""" |
| 1102 | info = zip_file.getinfo(name) |
| 1103 | offset = info.header_offset + len(info.FileHeader()) |
| 1104 | size = info.file_size |
| 1105 | return '%s:%d:%d' % (os.path.basename(name), offset, size) |
| 1106 | |
| 1107 | tokens = [] |
Tao Bao | 85f1698 | 2018-03-08 16:28:33 -0800 | [diff] [blame] | 1108 | tokens.extend(self._GetPrecomputed(zip_file)) |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1109 | for entry in self.required: |
| 1110 | tokens.append(ComputeEntryOffsetSize(entry)) |
| 1111 | for entry in self.optional: |
| 1112 | if entry in zip_file.namelist(): |
| 1113 | tokens.append(ComputeEntryOffsetSize(entry)) |
| 1114 | |
| 1115 | # 'META-INF/com/android/metadata' is required. We don't know its actual |
| 1116 | # offset and length (as well as the values for other entries). So we reserve |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1117 | # 15-byte as a placeholder ('offset:length'), which is sufficient to cover |
| 1118 | # the space for metadata entry. Because 'offset' allows a max of 10-digit |
| 1119 | # (i.e. ~9 GiB), with a max of 4-digit for the length. Note that all the |
| 1120 | # reserved space serves the metadata entry only. |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1121 | if reserve_space: |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1122 | tokens.append('metadata:' + ' ' * 15) |
Tao Bao | cc8e266 | 2018-03-01 19:30:00 -0800 | [diff] [blame] | 1123 | else: |
| 1124 | tokens.append(ComputeEntryOffsetSize(METADATA_NAME)) |
| 1125 | |
| 1126 | return ','.join(tokens) |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1127 | |
Tao Bao | 85f1698 | 2018-03-08 16:28:33 -0800 | [diff] [blame] | 1128 | def _GetPrecomputed(self, input_zip): |
| 1129 | """Computes the additional tokens to be included into the property-files. |
| 1130 | |
| 1131 | This applies to tokens without actual ZIP entries, such as |
| 1132 | payload_metadadata.bin. We want to expose the offset/size to updaters, so |
| 1133 | that they can download the payload metadata directly with the info. |
| 1134 | |
| 1135 | Args: |
| 1136 | input_zip: The input zip file. |
| 1137 | |
| 1138 | Returns: |
| 1139 | A list of strings (tokens) to be added to the property-files string. |
| 1140 | """ |
| 1141 | # pylint: disable=no-self-use |
| 1142 | # pylint: disable=unused-argument |
| 1143 | return [] |
| 1144 | |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1145 | |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1146 | class StreamingPropertyFiles(PropertyFiles): |
| 1147 | """A subclass for computing the property-files for streaming A/B OTAs.""" |
| 1148 | |
| 1149 | def __init__(self): |
| 1150 | super(StreamingPropertyFiles, self).__init__() |
| 1151 | self.name = 'ota-streaming-property-files' |
| 1152 | self.required = ( |
| 1153 | # payload.bin and payload_properties.txt must exist. |
| 1154 | 'payload.bin', |
| 1155 | 'payload_properties.txt', |
| 1156 | ) |
| 1157 | self.optional = ( |
| 1158 | # care_map.txt is available only if dm-verity is enabled. |
| 1159 | 'care_map.txt', |
| 1160 | # compatibility.zip is available only if target supports Treble. |
| 1161 | 'compatibility.zip', |
| 1162 | ) |
| 1163 | |
| 1164 | |
Tao Bao | 85f1698 | 2018-03-08 16:28:33 -0800 | [diff] [blame] | 1165 | class AbOtaPropertyFiles(StreamingPropertyFiles): |
| 1166 | """The property-files for A/B OTA that includes payload_metadata.bin info. |
| 1167 | |
| 1168 | Since P, we expose one more token (aka property-file), in addition to the ones |
| 1169 | for streaming A/B OTA, for a virtual entry of 'payload_metadata.bin'. |
| 1170 | 'payload_metadata.bin' is the header part of a payload ('payload.bin'), which |
| 1171 | doesn't exist as a separate ZIP entry, but can be used to verify if the |
| 1172 | payload can be applied on the given device. |
| 1173 | |
| 1174 | For backward compatibility, we keep both of the 'ota-streaming-property-files' |
| 1175 | and the newly added 'ota-property-files' in P. The new token will only be |
| 1176 | available in 'ota-property-files'. |
| 1177 | """ |
| 1178 | |
| 1179 | def __init__(self): |
| 1180 | super(AbOtaPropertyFiles, self).__init__() |
| 1181 | self.name = 'ota-property-files' |
| 1182 | |
| 1183 | def _GetPrecomputed(self, input_zip): |
| 1184 | offset, size = self._GetPayloadMetadataOffsetAndSize(input_zip) |
| 1185 | return ['payload_metadata.bin:{}:{}'.format(offset, size)] |
| 1186 | |
| 1187 | @staticmethod |
| 1188 | def _GetPayloadMetadataOffsetAndSize(input_zip): |
| 1189 | """Computes the offset and size of the payload metadata for a given package. |
| 1190 | |
| 1191 | (From system/update_engine/update_metadata.proto) |
| 1192 | A delta update file contains all the deltas needed to update a system from |
| 1193 | one specific version to another specific version. The update format is |
| 1194 | represented by this struct pseudocode: |
| 1195 | |
| 1196 | struct delta_update_file { |
| 1197 | char magic[4] = "CrAU"; |
| 1198 | uint64 file_format_version; |
| 1199 | uint64 manifest_size; // Size of protobuf DeltaArchiveManifest |
| 1200 | |
| 1201 | // Only present if format_version > 1: |
| 1202 | uint32 metadata_signature_size; |
| 1203 | |
| 1204 | // The Bzip2 compressed DeltaArchiveManifest |
| 1205 | char manifest[metadata_signature_size]; |
| 1206 | |
| 1207 | // The signature of the metadata (from the beginning of the payload up to |
| 1208 | // this location, not including the signature itself). This is a |
| 1209 | // serialized Signatures message. |
| 1210 | char medatada_signature_message[metadata_signature_size]; |
| 1211 | |
| 1212 | // Data blobs for files, no specific format. The specific offset |
| 1213 | // and length of each data blob is recorded in the DeltaArchiveManifest. |
| 1214 | struct { |
| 1215 | char data[]; |
| 1216 | } blobs[]; |
| 1217 | |
| 1218 | // These two are not signed: |
| 1219 | uint64 payload_signatures_message_size; |
| 1220 | char payload_signatures_message[]; |
| 1221 | }; |
| 1222 | |
| 1223 | 'payload-metadata.bin' contains all the bytes from the beginning of the |
| 1224 | payload, till the end of 'medatada_signature_message'. |
| 1225 | """ |
| 1226 | payload_info = input_zip.getinfo('payload.bin') |
| 1227 | payload_offset = payload_info.header_offset + len(payload_info.FileHeader()) |
| 1228 | payload_size = payload_info.file_size |
| 1229 | |
| 1230 | with input_zip.open('payload.bin', 'r') as payload_fp: |
| 1231 | header_bin = payload_fp.read(24) |
| 1232 | |
| 1233 | # network byte order (big-endian) |
| 1234 | header = struct.unpack("!IQQL", header_bin) |
| 1235 | |
| 1236 | # 'CrAU' |
| 1237 | magic = header[0] |
| 1238 | assert magic == 0x43724155, "Invalid magic: {:x}".format(magic) |
| 1239 | |
| 1240 | manifest_size = header[2] |
| 1241 | metadata_signature_size = header[3] |
| 1242 | metadata_total = 24 + manifest_size + metadata_signature_size |
| 1243 | assert metadata_total < payload_size |
| 1244 | |
| 1245 | return (payload_offset, metadata_total) |
| 1246 | |
| 1247 | |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1248 | class NonAbOtaPropertyFiles(PropertyFiles): |
| 1249 | """The property-files for non-A/B OTA. |
| 1250 | |
| 1251 | For non-A/B OTA, the property-files string contains the info for METADATA |
| 1252 | entry, with which a system updater can be fetched the package metadata prior |
| 1253 | to downloading the entire package. |
| 1254 | """ |
| 1255 | |
| 1256 | def __init__(self): |
| 1257 | super(NonAbOtaPropertyFiles, self).__init__() |
| 1258 | self.name = 'ota-property-files' |
| 1259 | |
| 1260 | |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1261 | def FinalizeMetadata(metadata, input_file, output_file, needed_property_files): |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1262 | """Finalizes the metadata and signs an A/B OTA package. |
| 1263 | |
| 1264 | In order to stream an A/B OTA package, we need 'ota-streaming-property-files' |
| 1265 | that contains the offsets and sizes for the ZIP entries. An example |
| 1266 | property-files string is as follows. |
| 1267 | |
| 1268 | "payload.bin:679:343,payload_properties.txt:378:45,metadata:69:379" |
| 1269 | |
| 1270 | OTA server can pass down this string, in addition to the package URL, to the |
| 1271 | system update client. System update client can then fetch individual ZIP |
| 1272 | entries (ZIP_STORED) directly at the given offset of the URL. |
| 1273 | |
| 1274 | Args: |
| 1275 | metadata: The metadata dict for the package. |
| 1276 | input_file: The input ZIP filename that doesn't contain the package METADATA |
| 1277 | entry yet. |
| 1278 | output_file: The final output ZIP filename. |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1279 | needed_property_files: The list of PropertyFiles' to be generated. |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1280 | """ |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1281 | |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1282 | def ComputeAllPropertyFiles(input_file, needed_property_files): |
| 1283 | # Write the current metadata entry with placeholders. |
| 1284 | with zipfile.ZipFile(input_file) as input_zip: |
| 1285 | for property_files in needed_property_files: |
| 1286 | metadata[property_files.name] = property_files.Compute(input_zip) |
| 1287 | namelist = input_zip.namelist() |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1288 | |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1289 | if METADATA_NAME in namelist: |
| 1290 | common.ZipDelete(input_file, METADATA_NAME) |
| 1291 | output_zip = zipfile.ZipFile(input_file, 'a') |
| 1292 | WriteMetadata(metadata, output_zip) |
| 1293 | common.ZipClose(output_zip) |
| 1294 | |
| 1295 | if OPTIONS.no_signing: |
| 1296 | return input_file |
| 1297 | |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1298 | prelim_signing = common.MakeTempFile(suffix='.zip') |
| 1299 | SignOutput(input_file, prelim_signing) |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1300 | return prelim_signing |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1301 | |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1302 | def FinalizeAllPropertyFiles(prelim_signing, needed_property_files): |
| 1303 | with zipfile.ZipFile(prelim_signing) as prelim_signing_zip: |
| 1304 | for property_files in needed_property_files: |
| 1305 | metadata[property_files.name] = property_files.Finalize( |
| 1306 | prelim_signing_zip, len(metadata[property_files.name])) |
| 1307 | |
| 1308 | # SignOutput(), which in turn calls signapk.jar, will possibly reorder the ZIP |
| 1309 | # entries, as well as padding the entry headers. We do a preliminary signing |
| 1310 | # (with an incomplete metadata entry) to allow that to happen. Then compute |
| 1311 | # the ZIP entry offsets, write back the final metadata and do the final |
| 1312 | # signing. |
| 1313 | prelim_signing = ComputeAllPropertyFiles(input_file, needed_property_files) |
| 1314 | try: |
| 1315 | FinalizeAllPropertyFiles(prelim_signing, needed_property_files) |
| 1316 | except PropertyFiles.InsufficientSpaceException: |
| 1317 | # Even with the preliminary signing, the entry orders may change |
| 1318 | # dramatically, which leads to insufficiently reserved space during the |
| 1319 | # first call to ComputeAllPropertyFiles(). In that case, we redo all the |
| 1320 | # preliminary signing works, based on the already ordered ZIP entries, to |
| 1321 | # address the issue. |
| 1322 | prelim_signing = ComputeAllPropertyFiles( |
| 1323 | prelim_signing, needed_property_files) |
| 1324 | FinalizeAllPropertyFiles(prelim_signing, needed_property_files) |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1325 | |
| 1326 | # Replace the METADATA entry. |
| 1327 | common.ZipDelete(prelim_signing, METADATA_NAME) |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1328 | output_zip = zipfile.ZipFile(prelim_signing, 'a') |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1329 | WriteMetadata(metadata, output_zip) |
| 1330 | common.ZipClose(output_zip) |
| 1331 | |
| 1332 | # Re-sign the package after updating the metadata entry. |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1333 | if OPTIONS.no_signing: |
| 1334 | output_file = prelim_signing |
| 1335 | else: |
| 1336 | SignOutput(prelim_signing, output_file) |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1337 | |
| 1338 | # Reopen the final signed zip to double check the streaming metadata. |
Tao Bao | d2ce2ed | 2018-03-16 12:59:42 -0700 | [diff] [blame] | 1339 | with zipfile.ZipFile(output_file) as output_zip: |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1340 | for property_files in needed_property_files: |
| 1341 | property_files.Verify(output_zip, metadata[property_files.name].strip()) |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1342 | |
| 1343 | |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1344 | def WriteBlockIncrementalOTAPackage(target_zip, source_zip, output_file): |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1345 | target_info = BuildInfo(OPTIONS.target_info_dict, OPTIONS.oem_dicts) |
| 1346 | source_info = BuildInfo(OPTIONS.source_info_dict, OPTIONS.oem_dicts) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1347 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1348 | target_api_version = target_info["recovery_api_version"] |
| 1349 | source_api_version = source_info["recovery_api_version"] |
| 1350 | if source_api_version == 0: |
Tao Bao | 3e30d97 | 2016-03-15 13:20:19 -0700 | [diff] [blame] | 1351 | print("WARNING: generating edify script for a source that " |
| 1352 | "can't install it.") |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1353 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1354 | script = edify_generator.EdifyGenerator( |
| 1355 | source_api_version, target_info, fstab=source_info["fstab"]) |
| 1356 | |
| 1357 | if target_info.oem_props or source_info.oem_props: |
| 1358 | if not OPTIONS.oem_no_mount: |
| 1359 | source_info.WriteMountOemScript(script) |
Tao Bao | 3806c23 | 2015-07-05 21:08:33 -0700 | [diff] [blame] | 1360 | |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 1361 | metadata = GetPackageMetadata(target_info, source_info) |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 1362 | |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1363 | if not OPTIONS.no_signing: |
| 1364 | staging_file = common.MakeTempFile(suffix='.zip') |
| 1365 | else: |
| 1366 | staging_file = output_file |
| 1367 | |
| 1368 | output_zip = zipfile.ZipFile( |
| 1369 | staging_file, "w", compression=zipfile.ZIP_DEFLATED) |
| 1370 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1371 | device_specific = common.DeviceSpecificParams( |
| 1372 | source_zip=source_zip, |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1373 | source_version=source_api_version, |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1374 | target_zip=target_zip, |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1375 | target_version=target_api_version, |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1376 | output_zip=output_zip, |
| 1377 | script=script, |
| 1378 | metadata=metadata, |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1379 | info_dict=source_info) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1380 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1381 | source_boot = common.GetBootableImage( |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1382 | "/tmp/boot.img", "boot.img", OPTIONS.source_tmp, "BOOT", source_info) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1383 | target_boot = common.GetBootableImage( |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1384 | "/tmp/boot.img", "boot.img", OPTIONS.target_tmp, "BOOT", target_info) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1385 | updating_boot = (not OPTIONS.two_step and |
| 1386 | (source_boot.data != target_boot.data)) |
| 1387 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1388 | target_recovery = common.GetBootableImage( |
| 1389 | "/tmp/recovery.img", "recovery.img", OPTIONS.target_tmp, "RECOVERY") |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1390 | |
Tao Bao | e709b09 | 2018-02-07 12:40:00 -0800 | [diff] [blame] | 1391 | # When target uses 'BOARD_EXT4_SHARE_DUP_BLOCKS := true', images may contain |
| 1392 | # shared blocks (i.e. some blocks will show up in multiple files' block |
| 1393 | # list). We can only allocate such shared blocks to the first "owner", and |
| 1394 | # disable imgdiff for all later occurrences. |
| 1395 | allow_shared_blocks = (source_info.get('ext4_share_dup_blocks') == "true" or |
| 1396 | target_info.get('ext4_share_dup_blocks') == "true") |
| 1397 | system_src = common.GetSparseImage("system", OPTIONS.source_tmp, source_zip, |
| 1398 | allow_shared_blocks) |
| 1399 | system_tgt = common.GetSparseImage("system", OPTIONS.target_tmp, target_zip, |
| 1400 | allow_shared_blocks) |
Tao Bao | dd2a589 | 2015-03-12 12:32:37 -0700 | [diff] [blame] | 1401 | |
Tao Bao | 0582cb6 | 2017-12-21 11:47:01 -0800 | [diff] [blame] | 1402 | blockimgdiff_version = max( |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1403 | int(i) for i in target_info.get("blockimgdiff_versions", "1").split(",")) |
Tao Bao | 0582cb6 | 2017-12-21 11:47:01 -0800 | [diff] [blame] | 1404 | assert blockimgdiff_version >= 3 |
Tao Bao | dd2a589 | 2015-03-12 12:32:37 -0700 | [diff] [blame] | 1405 | |
Tao Bao | f8acad1 | 2016-07-07 09:09:58 -0700 | [diff] [blame] | 1406 | # Check the first block of the source system partition for remount R/W only |
| 1407 | # if the filesystem is ext4. |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1408 | system_src_partition = source_info["fstab"]["/system"] |
Tao Bao | f8acad1 | 2016-07-07 09:09:58 -0700 | [diff] [blame] | 1409 | check_first_block = system_src_partition.fs_type == "ext4" |
Tao Bao | 293fd13 | 2016-06-11 12:19:23 -0700 | [diff] [blame] | 1410 | # Disable using imgdiff for squashfs. 'imgdiff -z' expects input files to be |
| 1411 | # in zip formats. However with squashfs, a) all files are compressed in LZ4; |
| 1412 | # b) the blocks listed in block map may not contain all the bytes for a given |
| 1413 | # file (because they're rounded to be 4K-aligned). |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1414 | system_tgt_partition = target_info["fstab"]["/system"] |
Tao Bao | f8acad1 | 2016-07-07 09:09:58 -0700 | [diff] [blame] | 1415 | disable_imgdiff = (system_src_partition.fs_type == "squashfs" or |
| 1416 | system_tgt_partition.fs_type == "squashfs") |
Doug Zongker | b34fcce | 2014-09-11 09:34:56 -0700 | [diff] [blame] | 1417 | system_diff = common.BlockDifference("system", system_tgt, system_src, |
Tianjie Xu | fc3422a | 2015-12-15 11:53:59 -0800 | [diff] [blame] | 1418 | check_first_block, |
Tao Bao | 293fd13 | 2016-06-11 12:19:23 -0700 | [diff] [blame] | 1419 | version=blockimgdiff_version, |
| 1420 | disable_imgdiff=disable_imgdiff) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 1421 | |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 1422 | if HasVendorPartition(target_zip): |
| 1423 | if not HasVendorPartition(source_zip): |
| 1424 | raise RuntimeError("can't generate incremental that adds /vendor") |
Tao Bao | e709b09 | 2018-02-07 12:40:00 -0800 | [diff] [blame] | 1425 | vendor_src = common.GetSparseImage("vendor", OPTIONS.source_tmp, source_zip, |
| 1426 | allow_shared_blocks) |
| 1427 | vendor_tgt = common.GetSparseImage("vendor", OPTIONS.target_tmp, target_zip, |
| 1428 | allow_shared_blocks) |
Tianjie Xu | fc3422a | 2015-12-15 11:53:59 -0800 | [diff] [blame] | 1429 | |
| 1430 | # Check first block of vendor partition for remount R/W only if |
| 1431 | # disk type is ext4 |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1432 | vendor_partition = source_info["fstab"]["/vendor"] |
Tao Bao | d8d14be | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 1433 | check_first_block = vendor_partition.fs_type == "ext4" |
Tao Bao | 293fd13 | 2016-06-11 12:19:23 -0700 | [diff] [blame] | 1434 | disable_imgdiff = vendor_partition.fs_type == "squashfs" |
Doug Zongker | b34fcce | 2014-09-11 09:34:56 -0700 | [diff] [blame] | 1435 | vendor_diff = common.BlockDifference("vendor", vendor_tgt, vendor_src, |
Tianjie Xu | fc3422a | 2015-12-15 11:53:59 -0800 | [diff] [blame] | 1436 | check_first_block, |
Tao Bao | 293fd13 | 2016-06-11 12:19:23 -0700 | [diff] [blame] | 1437 | version=blockimgdiff_version, |
| 1438 | disable_imgdiff=disable_imgdiff) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 1439 | else: |
| 1440 | vendor_diff = None |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1441 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 1442 | AddCompatibilityArchiveIfTrebleEnabled( |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1443 | target_zip, output_zip, target_info, source_info) |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 1444 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1445 | # Assertions (e.g. device properties check). |
| 1446 | target_info.WriteDeviceAssertions(script, OPTIONS.oem_no_mount) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1447 | device_specific.IncrementalOTA_Assertions() |
| 1448 | |
| 1449 | # Two-step incremental package strategy (in chronological order, |
| 1450 | # which is *not* the order in which the generated script has |
| 1451 | # things): |
| 1452 | # |
| 1453 | # if stage is not "2/3" or "3/3": |
| 1454 | # do verification on current system |
| 1455 | # write recovery image to boot partition |
| 1456 | # set stage to "2/3" |
| 1457 | # reboot to boot partition and restart recovery |
| 1458 | # else if stage is "2/3": |
| 1459 | # write recovery image to recovery partition |
| 1460 | # set stage to "3/3" |
| 1461 | # reboot to recovery partition and restart recovery |
| 1462 | # else: |
| 1463 | # (stage must be "3/3") |
| 1464 | # perform update: |
| 1465 | # patch system files, etc. |
| 1466 | # force full install of new boot image |
| 1467 | # set up system to update recovery partition on first boot |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1468 | # complete script normally |
| 1469 | # (allow recovery to mark itself finished and reboot) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1470 | |
| 1471 | if OPTIONS.two_step: |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1472 | if not source_info.get("multistage_support"): |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1473 | assert False, "two-step packages not supported by this build" |
Tao Bao | 24604cc | 2018-02-01 16:25:44 -0800 | [diff] [blame] | 1474 | fs = source_info["fstab"]["/misc"] |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1475 | assert fs.fs_type.upper() == "EMMC", \ |
| 1476 | "two-step packages only supported on devices with EMMC /misc partitions" |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1477 | bcb_dev = {"bcb_dev" : fs.device} |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1478 | common.ZipWriteStr(output_zip, "recovery.img", target_recovery.data) |
| 1479 | script.AppendExtra(""" |
Michael Runge | fb8886d | 2014-10-23 13:51:04 -0700 | [diff] [blame] | 1480 | if get_stage("%(bcb_dev)s") == "2/3" then |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1481 | """ % bcb_dev) |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 1482 | |
| 1483 | # Stage 2/3: Write recovery image to /recovery (currently running /boot). |
| 1484 | script.Comment("Stage 2/3") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1485 | script.AppendExtra("sleep(20);\n") |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1486 | script.WriteRawImage("/recovery", "recovery.img") |
| 1487 | script.AppendExtra(""" |
| 1488 | set_stage("%(bcb_dev)s", "3/3"); |
| 1489 | reboot_now("%(bcb_dev)s", "recovery"); |
Michael Runge | fb8886d | 2014-10-23 13:51:04 -0700 | [diff] [blame] | 1490 | else if get_stage("%(bcb_dev)s") != "3/3" then |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1491 | """ % bcb_dev) |
| 1492 | |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 1493 | # Stage 1/3: (a) Verify the current system. |
| 1494 | script.Comment("Stage 1/3") |
| 1495 | |
Tao Bao | 6c55a8a | 2015-04-08 15:30:27 -0700 | [diff] [blame] | 1496 | # Dump fingerprints |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1497 | script.Print("Source: {}".format(source_info.fingerprint)) |
| 1498 | script.Print("Target: {}".format(target_info.fingerprint)) |
Tao Bao | 6c55a8a | 2015-04-08 15:30:27 -0700 | [diff] [blame] | 1499 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1500 | script.Print("Verifying current system...") |
| 1501 | |
| 1502 | device_specific.IncrementalOTA_VerifyBegin() |
| 1503 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1504 | WriteFingerprintAssertion(script, target_info, source_info) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1505 | |
Tao Bao | d8d14be | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 1506 | # Check the required cache size (i.e. stashed blocks). |
| 1507 | size = [] |
| 1508 | if system_diff: |
| 1509 | size.append(system_diff.required_cache) |
| 1510 | if vendor_diff: |
| 1511 | size.append(vendor_diff.required_cache) |
| 1512 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1513 | if updating_boot: |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1514 | boot_type, boot_device = common.GetTypeAndDevice("/boot", source_info) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1515 | d = common.Difference(target_boot, source_boot) |
| 1516 | _, _, d = d.ComputePatch() |
Doug Zongker | f834008 | 2014-08-05 10:39:37 -0700 | [diff] [blame] | 1517 | if d is None: |
| 1518 | include_full_boot = True |
| 1519 | common.ZipWriteStr(output_zip, "boot.img", target_boot.data) |
| 1520 | else: |
| 1521 | include_full_boot = False |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1522 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1523 | print("boot target: %d source: %d diff: %d" % ( |
| 1524 | target_boot.size, source_boot.size, len(d))) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1525 | |
Doug Zongker | f834008 | 2014-08-05 10:39:37 -0700 | [diff] [blame] | 1526 | common.ZipWriteStr(output_zip, "patch/boot.img.p", d) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1527 | |
Tao Bao | 6d8ec58 | 2018-06-12 14:53:12 -0700 | [diff] [blame] | 1528 | # TODO(b/110106408): Remove after properly handling the SHA-1 embedded in |
| 1529 | # the filename argument in updater code. Prior to that, explicitly list |
| 1530 | # the SHA-1 of the source image, in case the updater tries to find a |
| 1531 | # matching backup from /cache. Similarly for the call to |
| 1532 | # script.ApplyPatch() below. |
Doug Zongker | f834008 | 2014-08-05 10:39:37 -0700 | [diff] [blame] | 1533 | script.PatchCheck("%s:%s:%d:%s:%d:%s" % |
| 1534 | (boot_type, boot_device, |
| 1535 | source_boot.size, source_boot.sha1, |
Tao Bao | 6d8ec58 | 2018-06-12 14:53:12 -0700 | [diff] [blame] | 1536 | target_boot.size, target_boot.sha1), |
| 1537 | source_boot.sha1) |
Tao Bao | d8d14be | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 1538 | size.append(target_boot.size) |
| 1539 | |
| 1540 | if size: |
| 1541 | script.CacheFreeSpaceCheck(max(size)) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1542 | |
| 1543 | device_specific.IncrementalOTA_VerifyEnd() |
| 1544 | |
| 1545 | if OPTIONS.two_step: |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 1546 | # Stage 1/3: (b) Write recovery image to /boot. |
| 1547 | _WriteRecoveryImageToBoot(script, output_zip) |
| 1548 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1549 | script.AppendExtra(""" |
| 1550 | set_stage("%(bcb_dev)s", "2/3"); |
| 1551 | reboot_now("%(bcb_dev)s", ""); |
| 1552 | else |
| 1553 | """ % bcb_dev) |
| 1554 | |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 1555 | # Stage 3/3: Make changes. |
| 1556 | script.Comment("Stage 3/3") |
| 1557 | |
Jesse Zhao | 75bcea0 | 2015-01-06 10:59:53 -0800 | [diff] [blame] | 1558 | # Verify the existing partitions. |
Tao Bao | d522bdc | 2016-04-12 15:53:16 -0700 | [diff] [blame] | 1559 | system_diff.WriteVerifyScript(script, touched_blocks_only=True) |
Jesse Zhao | 75bcea0 | 2015-01-06 10:59:53 -0800 | [diff] [blame] | 1560 | if vendor_diff: |
Tao Bao | d522bdc | 2016-04-12 15:53:16 -0700 | [diff] [blame] | 1561 | vendor_diff.WriteVerifyScript(script, touched_blocks_only=True) |
Jesse Zhao | 75bcea0 | 2015-01-06 10:59:53 -0800 | [diff] [blame] | 1562 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1563 | script.Comment("---- start making changes here ----") |
| 1564 | |
| 1565 | device_specific.IncrementalOTA_InstallBegin() |
| 1566 | |
Doug Zongker | ab7ca1d | 2014-08-26 10:40:28 -0700 | [diff] [blame] | 1567 | system_diff.WriteScript(script, output_zip, |
| 1568 | progress=0.8 if vendor_diff else 0.9) |
Tao Bao | 68658c0 | 2015-06-01 13:40:49 -0700 | [diff] [blame] | 1569 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 1570 | if vendor_diff: |
Doug Zongker | ab7ca1d | 2014-08-26 10:40:28 -0700 | [diff] [blame] | 1571 | vendor_diff.WriteScript(script, output_zip, progress=0.1) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1572 | |
| 1573 | if OPTIONS.two_step: |
| 1574 | common.ZipWriteStr(output_zip, "boot.img", target_boot.data) |
| 1575 | script.WriteRawImage("/boot", "boot.img") |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1576 | print("writing full boot image (forced by two-step mode)") |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1577 | |
| 1578 | if not OPTIONS.two_step: |
| 1579 | if updating_boot: |
Doug Zongker | f834008 | 2014-08-05 10:39:37 -0700 | [diff] [blame] | 1580 | if include_full_boot: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1581 | print("boot image changed; including full.") |
Doug Zongker | f834008 | 2014-08-05 10:39:37 -0700 | [diff] [blame] | 1582 | script.Print("Installing boot image...") |
| 1583 | script.WriteRawImage("/boot", "boot.img") |
| 1584 | else: |
| 1585 | # Produce the boot image by applying a patch to the current |
| 1586 | # contents of the boot partition, and write it back to the |
| 1587 | # partition. |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1588 | print("boot image changed; including patch.") |
Doug Zongker | f834008 | 2014-08-05 10:39:37 -0700 | [diff] [blame] | 1589 | script.Print("Patching boot image...") |
| 1590 | script.ShowProgress(0.1, 10) |
| 1591 | script.ApplyPatch("%s:%s:%d:%s:%d:%s" |
| 1592 | % (boot_type, boot_device, |
| 1593 | source_boot.size, source_boot.sha1, |
| 1594 | target_boot.size, target_boot.sha1), |
| 1595 | "-", |
| 1596 | target_boot.size, target_boot.sha1, |
| 1597 | source_boot.sha1, "patch/boot.img.p") |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1598 | else: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1599 | print("boot image unchanged; skipping.") |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1600 | |
| 1601 | # Do device-specific installation (eg, write radio image). |
| 1602 | device_specific.IncrementalOTA_InstallEnd() |
| 1603 | |
| 1604 | if OPTIONS.extra_script is not None: |
| 1605 | script.AppendExtra(OPTIONS.extra_script) |
| 1606 | |
Doug Zongker | 922206e | 2014-03-04 13:16:24 -0800 | [diff] [blame] | 1607 | if OPTIONS.wipe_user_data: |
| 1608 | script.Print("Erasing user data...") |
| 1609 | script.FormatPartition("/data") |
| 1610 | |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1611 | if OPTIONS.two_step: |
| 1612 | script.AppendExtra(""" |
| 1613 | set_stage("%(bcb_dev)s", ""); |
| 1614 | endif; |
| 1615 | endif; |
| 1616 | """ % bcb_dev) |
| 1617 | |
| 1618 | script.SetProgress(1) |
Tao Bao | 4996cf0 | 2016-03-08 17:53:39 -0800 | [diff] [blame] | 1619 | # For downgrade OTAs, we prefer to use the update-binary in the source |
| 1620 | # build that is actually newer than the one in the target build. |
| 1621 | if OPTIONS.downgrade: |
| 1622 | script.AddToZip(source_zip, output_zip, input_path=OPTIONS.updater_binary) |
| 1623 | else: |
| 1624 | script.AddToZip(target_zip, output_zip, input_path=OPTIONS.updater_binary) |
Tao Bao | d8d14be | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 1625 | metadata["ota-required-cache"] = str(script.required_cache) |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1626 | |
| 1627 | # We haven't written the metadata entry yet, which will be handled in |
| 1628 | # FinalizeMetadata(). |
| 1629 | common.ZipClose(output_zip) |
| 1630 | |
| 1631 | # Sign the generated zip package unless no_signing is specified. |
| 1632 | needed_property_files = ( |
| 1633 | NonAbOtaPropertyFiles(), |
| 1634 | ) |
| 1635 | FinalizeMetadata(metadata, staging_file, output_file, needed_property_files) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 1636 | |
Doug Zongker | 32b527d | 2014-03-04 10:03:02 -0800 | [diff] [blame] | 1637 | |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1638 | def GetTargetFilesZipForSecondaryImages(input_file, skip_postinstall=False): |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1639 | """Returns a target-files.zip file for generating secondary payload. |
| 1640 | |
| 1641 | Although the original target-files.zip already contains secondary slot |
| 1642 | images (i.e. IMAGES/system_other.img), we need to rename the files to the |
| 1643 | ones without _other suffix. Note that we cannot instead modify the names in |
| 1644 | META/ab_partitions.txt, because there are no matching partitions on device. |
| 1645 | |
| 1646 | For the partitions that don't have secondary images, the ones for primary |
| 1647 | slot will be used. This is to ensure that we always have valid boot, vbmeta, |
| 1648 | bootloader images in the inactive slot. |
| 1649 | |
| 1650 | Args: |
| 1651 | input_file: The input target-files.zip file. |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1652 | skip_postinstall: Whether to skip copying the postinstall config file. |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1653 | |
| 1654 | Returns: |
| 1655 | The filename of the target-files.zip for generating secondary payload. |
| 1656 | """ |
| 1657 | target_file = common.MakeTempFile(prefix="targetfiles-", suffix=".zip") |
| 1658 | target_zip = zipfile.ZipFile(target_file, 'w', allowZip64=True) |
| 1659 | |
Tao Bao | dba59ee | 2018-01-09 13:21:02 -0800 | [diff] [blame] | 1660 | with zipfile.ZipFile(input_file, 'r') as input_zip: |
| 1661 | infolist = input_zip.infolist() |
Tao Bao | 1248980 | 2018-07-12 14:47:38 -0700 | [diff] [blame] | 1662 | namelist = input_zip.namelist() |
| 1663 | |
| 1664 | # Additionally unzip 'RADIO/*' if exists. |
| 1665 | unzip_pattern = UNZIP_PATTERN[:] |
| 1666 | if any([entry.startswith('RADIO/') for entry in namelist]): |
| 1667 | unzip_pattern.append('RADIO/*') |
| 1668 | input_tmp = common.UnzipTemp(input_file, unzip_pattern) |
Tao Bao | dba59ee | 2018-01-09 13:21:02 -0800 | [diff] [blame] | 1669 | |
| 1670 | for info in infolist: |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1671 | unzipped_file = os.path.join(input_tmp, *info.filename.split('/')) |
| 1672 | if info.filename == 'IMAGES/system_other.img': |
| 1673 | common.ZipWrite(target_zip, unzipped_file, arcname='IMAGES/system.img') |
| 1674 | |
| 1675 | # Primary images and friends need to be skipped explicitly. |
| 1676 | elif info.filename in ('IMAGES/system.img', |
| 1677 | 'IMAGES/system.map'): |
| 1678 | pass |
| 1679 | |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1680 | # Skip copying the postinstall config if requested. |
| 1681 | elif skip_postinstall and info.filename == POSTINSTALL_CONFIG: |
| 1682 | pass |
| 1683 | |
Tao Bao | 1248980 | 2018-07-12 14:47:38 -0700 | [diff] [blame] | 1684 | elif info.filename.startswith(('META/', 'IMAGES/', 'RADIO/')): |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1685 | common.ZipWrite(target_zip, unzipped_file, arcname=info.filename) |
| 1686 | |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1687 | common.ZipClose(target_zip) |
| 1688 | |
| 1689 | return target_file |
| 1690 | |
| 1691 | |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1692 | def GetTargetFilesZipWithoutPostinstallConfig(input_file): |
| 1693 | """Returns a target-files.zip that's not containing postinstall_config.txt. |
| 1694 | |
| 1695 | This allows brillo_update_payload script to skip writing all the postinstall |
| 1696 | hooks in the generated payload. The input target-files.zip file will be |
| 1697 | duplicated, with 'META/postinstall_config.txt' skipped. If input_file doesn't |
| 1698 | contain the postinstall_config.txt entry, the input file will be returned. |
| 1699 | |
| 1700 | Args: |
| 1701 | input_file: The input target-files.zip filename. |
| 1702 | |
| 1703 | Returns: |
| 1704 | The filename of target-files.zip that doesn't contain postinstall config. |
| 1705 | """ |
| 1706 | # We should only make a copy if postinstall_config entry exists. |
| 1707 | with zipfile.ZipFile(input_file, 'r') as input_zip: |
| 1708 | if POSTINSTALL_CONFIG not in input_zip.namelist(): |
| 1709 | return input_file |
| 1710 | |
| 1711 | target_file = common.MakeTempFile(prefix="targetfiles-", suffix=".zip") |
| 1712 | shutil.copyfile(input_file, target_file) |
| 1713 | common.ZipDelete(target_file, POSTINSTALL_CONFIG) |
| 1714 | return target_file |
| 1715 | |
| 1716 | |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1717 | def WriteABOTAPackageWithBrilloScript(target_file, output_file, |
| 1718 | source_file=None): |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1719 | """Generates an Android OTA package that has A/B update payload.""" |
Tao Bao | dea0f8b | 2016-06-20 17:55:06 -0700 | [diff] [blame] | 1720 | # Stage the output zip package for package signing. |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 1721 | if not OPTIONS.no_signing: |
| 1722 | staging_file = common.MakeTempFile(suffix='.zip') |
| 1723 | else: |
| 1724 | staging_file = output_file |
Tao Bao | a652c00 | 2018-03-01 19:31:38 -0800 | [diff] [blame] | 1725 | output_zip = zipfile.ZipFile(staging_file, "w", |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1726 | compression=zipfile.ZIP_DEFLATED) |
| 1727 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1728 | if source_file is not None: |
| 1729 | target_info = BuildInfo(OPTIONS.target_info_dict, OPTIONS.oem_dicts) |
| 1730 | source_info = BuildInfo(OPTIONS.source_info_dict, OPTIONS.oem_dicts) |
| 1731 | else: |
| 1732 | target_info = BuildInfo(OPTIONS.info_dict, OPTIONS.oem_dicts) |
| 1733 | source_info = None |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1734 | |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1735 | # Metadata to comply with Android OTA package format. |
Tao Bao | df3a48b | 2018-01-10 16:30:43 -0800 | [diff] [blame] | 1736 | metadata = GetPackageMetadata(target_info, source_info) |
Tao Bao | b31892e | 2017-02-07 11:21:17 -0800 | [diff] [blame] | 1737 | |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1738 | if OPTIONS.skip_postinstall: |
| 1739 | target_file = GetTargetFilesZipWithoutPostinstallConfig(target_file) |
| 1740 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 1741 | # Generate payload. |
| 1742 | payload = Payload() |
| 1743 | |
| 1744 | # Enforce a max timestamp this payload can be applied on top of. |
Tao Bao | ff1b86e | 2017-10-03 14:17:57 -0700 | [diff] [blame] | 1745 | if OPTIONS.downgrade: |
Tao Bao | 2a12ed7 | 2018-01-22 11:35:00 -0800 | [diff] [blame] | 1746 | max_timestamp = source_info.GetBuildProp("ro.build.date.utc") |
Tao Bao | ff1b86e | 2017-10-03 14:17:57 -0700 | [diff] [blame] | 1747 | else: |
| 1748 | max_timestamp = metadata["post-timestamp"] |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 1749 | additional_args = ["--max_timestamp", max_timestamp] |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1750 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 1751 | payload.Generate(target_file, source_file, additional_args) |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1752 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 1753 | # Sign the payload. |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1754 | payload_signer = PayloadSigner() |
| 1755 | payload.Sign(payload_signer) |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1756 | |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 1757 | # Write the payload into output zip. |
| 1758 | payload.WriteToZip(output_zip) |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1759 | |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1760 | # Generate and include the secondary payload that installs secondary images |
| 1761 | # (e.g. system_other.img). |
| 1762 | if OPTIONS.include_secondary: |
| 1763 | # We always include a full payload for the secondary slot, even when |
| 1764 | # building an incremental OTA. See the comments for "--include_secondary". |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1765 | secondary_target_file = GetTargetFilesZipForSecondaryImages( |
| 1766 | target_file, OPTIONS.skip_postinstall) |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 1767 | secondary_payload = Payload(secondary=True) |
Tao Bao | db1fe41 | 2018-02-09 23:15:05 -0800 | [diff] [blame] | 1768 | secondary_payload.Generate(secondary_target_file, |
| 1769 | additional_args=additional_args) |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1770 | secondary_payload.Sign(payload_signer) |
Tao Bao | 667ff57 | 2018-02-10 00:02:40 -0800 | [diff] [blame] | 1771 | secondary_payload.WriteToZip(output_zip) |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1772 | |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 1773 | # If dm-verity is supported for the device, copy contents of care_map |
| 1774 | # into A/B OTA package. |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 1775 | target_zip = zipfile.ZipFile(target_file, "r") |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1776 | if (target_info.get("verity") == "true" or |
| 1777 | target_info.get("avb_enable") == "true"): |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 1778 | care_map_path = "META/care_map.txt" |
| 1779 | namelist = target_zip.namelist() |
| 1780 | if care_map_path in namelist: |
| 1781 | care_map_data = target_zip.read(care_map_path) |
Tao Bao | 40b1882 | 2018-01-30 18:19:04 -0800 | [diff] [blame] | 1782 | # In order to support streaming, care_map.txt needs to be packed as |
| 1783 | # ZIP_STORED. |
Tao Bao | c96316c | 2017-01-24 22:10:49 -0800 | [diff] [blame] | 1784 | common.ZipWriteStr(output_zip, "care_map.txt", care_map_data, |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1785 | compress_type=zipfile.ZIP_STORED) |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 1786 | else: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1787 | print("Warning: cannot find care map file in target_file package") |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 1788 | |
Tao Bao | bcd1d16 | 2017-08-26 13:10:26 -0700 | [diff] [blame] | 1789 | AddCompatibilityArchiveIfTrebleEnabled( |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1790 | target_zip, output_zip, target_info, source_info) |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 1791 | |
Tao Bao | 21803d3 | 2017-04-19 10:16:09 -0700 | [diff] [blame] | 1792 | common.ZipClose(target_zip) |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 1793 | |
Tao Bao | fe5b69a | 2018-03-02 09:47:43 -0800 | [diff] [blame] | 1794 | # We haven't written the metadata entry yet, which will be handled in |
| 1795 | # FinalizeMetadata(). |
Tao Bao | c96316c | 2017-01-24 22:10:49 -0800 | [diff] [blame] | 1796 | common.ZipClose(output_zip) |
| 1797 | |
Tao Bao | 85f1698 | 2018-03-08 16:28:33 -0800 | [diff] [blame] | 1798 | # AbOtaPropertyFiles intends to replace StreamingPropertyFiles, as it covers |
| 1799 | # all the info of the latter. However, system updaters and OTA servers need to |
| 1800 | # take time to switch to the new flag. We keep both of the flags for |
| 1801 | # P-timeframe, and will remove StreamingPropertyFiles in later release. |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1802 | needed_property_files = ( |
Tao Bao | 85f1698 | 2018-03-08 16:28:33 -0800 | [diff] [blame] | 1803 | AbOtaPropertyFiles(), |
Tao Bao | d3fc38a | 2018-03-08 16:09:01 -0800 | [diff] [blame] | 1804 | StreamingPropertyFiles(), |
| 1805 | ) |
| 1806 | FinalizeMetadata(metadata, staging_file, output_file, needed_property_files) |
Tao Bao | c96316c | 2017-01-24 22:10:49 -0800 | [diff] [blame] | 1807 | |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1808 | |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1809 | def main(argv): |
| 1810 | |
| 1811 | def option_handler(o, a): |
Tao Bao | 4b76a0e | 2017-10-31 12:13:33 -0700 | [diff] [blame] | 1812 | if o in ("-k", "--package_key"): |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1813 | OPTIONS.package_key = a |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1814 | elif o in ("-i", "--incremental_from"): |
| 1815 | OPTIONS.incremental_source = a |
Tao Bao | 43078aa | 2015-04-21 14:32:35 -0700 | [diff] [blame] | 1816 | elif o == "--full_radio": |
| 1817 | OPTIONS.full_radio = True |
leozwang | aa6c1a1 | 2015-08-14 10:57:58 -0700 | [diff] [blame] | 1818 | elif o == "--full_bootloader": |
| 1819 | OPTIONS.full_bootloader = True |
Tao Bao | 337633f | 2017-12-06 15:20:19 -0800 | [diff] [blame] | 1820 | elif o == "--wipe_user_data": |
Doug Zongker | dbfaae5 | 2009-04-21 17:12:54 -0700 | [diff] [blame] | 1821 | OPTIONS.wipe_user_data = True |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 1822 | elif o == "--downgrade": |
| 1823 | OPTIONS.downgrade = True |
| 1824 | OPTIONS.wipe_user_data = True |
Tao Bao | 3e6161a | 2017-02-28 11:48:48 -0800 | [diff] [blame] | 1825 | elif o == "--override_timestamp": |
Tao Bao | faa8e0b | 2018-04-12 14:31:43 -0700 | [diff] [blame] | 1826 | OPTIONS.downgrade = True |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 1827 | elif o in ("-o", "--oem_settings"): |
Alain Vongsouvanh | 7f804ba | 2017-02-16 13:06:55 -0800 | [diff] [blame] | 1828 | OPTIONS.oem_source = a.split(',') |
Tao Bao | 8608cde | 2016-02-25 19:49:55 -0800 | [diff] [blame] | 1829 | elif o == "--oem_no_mount": |
| 1830 | OPTIONS.oem_no_mount = True |
Doug Zongker | 1c390a2 | 2009-05-14 19:06:36 -0700 | [diff] [blame] | 1831 | elif o in ("-e", "--extra_script"): |
| 1832 | OPTIONS.extra_script = a |
Martin Blumenstingl | 374e114 | 2014-05-31 20:42:55 +0200 | [diff] [blame] | 1833 | elif o in ("-t", "--worker_threads"): |
| 1834 | if a.isdigit(): |
| 1835 | OPTIONS.worker_threads = int(a) |
| 1836 | else: |
| 1837 | raise ValueError("Cannot parse value %r for option %r - only " |
| 1838 | "integers are allowed." % (a, o)) |
Doug Zongker | 9b23f2c | 2013-11-25 14:44:12 -0800 | [diff] [blame] | 1839 | elif o in ("-2", "--two_step"): |
| 1840 | OPTIONS.two_step = True |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1841 | elif o == "--include_secondary": |
| 1842 | OPTIONS.include_secondary = True |
Doug Zongker | 26e6619 | 2014-02-20 13:22:07 -0800 | [diff] [blame] | 1843 | elif o == "--no_signing": |
Takeshi Kanemoto | e153b34 | 2013-11-14 17:20:50 +0900 | [diff] [blame] | 1844 | OPTIONS.no_signing = True |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1845 | elif o == "--verify": |
Michael Runge | 63f01de | 2014-10-28 19:24:19 -0700 | [diff] [blame] | 1846 | OPTIONS.verify = True |
Doug Zongker | 26e6619 | 2014-02-20 13:22:07 -0800 | [diff] [blame] | 1847 | elif o == "--block": |
| 1848 | OPTIONS.block_based = True |
Doug Zongker | 2556848 | 2014-03-03 10:21:27 -0800 | [diff] [blame] | 1849 | elif o in ("-b", "--binary"): |
| 1850 | OPTIONS.updater_binary = a |
Tao Bao | 8dcf738 | 2015-05-21 14:09:49 -0700 | [diff] [blame] | 1851 | elif o == "--stash_threshold": |
| 1852 | try: |
| 1853 | OPTIONS.stash_threshold = float(a) |
| 1854 | except ValueError: |
| 1855 | raise ValueError("Cannot parse value %r for option %r - expecting " |
| 1856 | "a float" % (a, o)) |
Tao Bao | d62c603 | 2015-11-30 09:40:20 -0800 | [diff] [blame] | 1857 | elif o == "--log_diff": |
| 1858 | OPTIONS.log_diff = a |
Tao Bao | dea0f8b | 2016-06-20 17:55:06 -0700 | [diff] [blame] | 1859 | elif o == "--payload_signer": |
| 1860 | OPTIONS.payload_signer = a |
Baligh Uddin | 2abbbd0 | 2016-06-22 12:14:16 -0700 | [diff] [blame] | 1861 | elif o == "--payload_signer_args": |
| 1862 | OPTIONS.payload_signer_args = shlex.split(a) |
Dan Willemsen | cea5cd2 | 2017-03-21 14:44:27 -0700 | [diff] [blame] | 1863 | elif o == "--extracted_input_target_files": |
| 1864 | OPTIONS.extracted_input = a |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1865 | elif o == "--skip_postinstall": |
| 1866 | OPTIONS.skip_postinstall = True |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1867 | else: |
| 1868 | return False |
Doug Zongker | dbfaae5 | 2009-04-21 17:12:54 -0700 | [diff] [blame] | 1869 | return True |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1870 | |
| 1871 | args = common.ParseOptions(argv, __doc__, |
Tao Bao | 337633f | 2017-12-06 15:20:19 -0800 | [diff] [blame] | 1872 | extra_opts="b:k:i:d:e:t:2o:", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1873 | extra_long_opts=[ |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1874 | "package_key=", |
| 1875 | "incremental_from=", |
Tao Bao | 43078aa | 2015-04-21 14:32:35 -0700 | [diff] [blame] | 1876 | "full_radio", |
leozwang | aa6c1a1 | 2015-08-14 10:57:58 -0700 | [diff] [blame] | 1877 | "full_bootloader", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1878 | "wipe_user_data", |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 1879 | "downgrade", |
Tao Bao | 3e6161a | 2017-02-28 11:48:48 -0800 | [diff] [blame] | 1880 | "override_timestamp", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1881 | "extra_script=", |
| 1882 | "worker_threads=", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1883 | "two_step", |
Tao Bao | f7140c0 | 2018-01-30 17:09:24 -0800 | [diff] [blame] | 1884 | "include_secondary", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1885 | "no_signing", |
| 1886 | "block", |
| 1887 | "binary=", |
| 1888 | "oem_settings=", |
Tao Bao | 8608cde | 2016-02-25 19:49:55 -0800 | [diff] [blame] | 1889 | "oem_no_mount", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1890 | "verify", |
Tao Bao | 8dcf738 | 2015-05-21 14:09:49 -0700 | [diff] [blame] | 1891 | "stash_threshold=", |
Tao Bao | d62c603 | 2015-11-30 09:40:20 -0800 | [diff] [blame] | 1892 | "log_diff=", |
Tao Bao | dea0f8b | 2016-06-20 17:55:06 -0700 | [diff] [blame] | 1893 | "payload_signer=", |
Baligh Uddin | 2abbbd0 | 2016-06-22 12:14:16 -0700 | [diff] [blame] | 1894 | "payload_signer_args=", |
Dan Willemsen | cea5cd2 | 2017-03-21 14:44:27 -0700 | [diff] [blame] | 1895 | "extracted_input_target_files=", |
Tao Bao | 15a146a | 2018-02-21 16:06:59 -0800 | [diff] [blame] | 1896 | "skip_postinstall", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 1897 | ], extra_option_handler=option_handler) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 1898 | |
| 1899 | if len(args) != 2: |
| 1900 | common.Usage(__doc__) |
| 1901 | sys.exit(1) |
| 1902 | |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 1903 | if OPTIONS.downgrade: |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 1904 | # We should only allow downgrading incrementals (as opposed to full). |
| 1905 | # Otherwise the device may go back from arbitrary build with this full |
| 1906 | # OTA package. |
| 1907 | if OPTIONS.incremental_source is None: |
Elliott Hughes | d8a52f9 | 2016-06-20 14:35:47 -0700 | [diff] [blame] | 1908 | raise ValueError("Cannot generate downgradable full OTAs") |
Tao Bao | 5d18256 | 2016-02-23 11:38:39 -0800 | [diff] [blame] | 1909 | |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1910 | # Load the build info dicts from the zip directly or the extracted input |
| 1911 | # directory. We don't need to unzip the entire target-files zips, because they |
| 1912 | # won't be needed for A/B OTAs (brillo_update_payload does that on its own). |
| 1913 | # When loading the info dicts, we don't need to provide the second parameter |
| 1914 | # to common.LoadInfoDict(). Specifying the second parameter allows replacing |
| 1915 | # some properties with their actual paths, such as 'selinux_fc', |
| 1916 | # 'ramdisk_dir', which won't be used during OTA generation. |
Dan Willemsen | cea5cd2 | 2017-03-21 14:44:27 -0700 | [diff] [blame] | 1917 | if OPTIONS.extracted_input is not None: |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1918 | OPTIONS.info_dict = common.LoadInfoDict(OPTIONS.extracted_input) |
Dan Willemsen | cea5cd2 | 2017-03-21 14:44:27 -0700 | [diff] [blame] | 1919 | else: |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1920 | with zipfile.ZipFile(args[0], 'r') as input_zip: |
| 1921 | OPTIONS.info_dict = common.LoadInfoDict(input_zip) |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1922 | |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1923 | if OPTIONS.verbose: |
| 1924 | print("--- target info ---") |
| 1925 | common.DumpInfoDict(OPTIONS.info_dict) |
| 1926 | |
| 1927 | # Load the source build dict if applicable. |
| 1928 | if OPTIONS.incremental_source is not None: |
| 1929 | OPTIONS.target_info_dict = OPTIONS.info_dict |
| 1930 | with zipfile.ZipFile(OPTIONS.incremental_source, 'r') as source_zip: |
| 1931 | OPTIONS.source_info_dict = common.LoadInfoDict(source_zip) |
| 1932 | |
| 1933 | if OPTIONS.verbose: |
| 1934 | print("--- source info ---") |
| 1935 | common.DumpInfoDict(OPTIONS.source_info_dict) |
| 1936 | |
| 1937 | # Load OEM dicts if provided. |
Tao Bao | 481bab8 | 2017-12-21 11:23:09 -0800 | [diff] [blame] | 1938 | OPTIONS.oem_dicts = _LoadOemDicts(OPTIONS.oem_source) |
| 1939 | |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1940 | ab_update = OPTIONS.info_dict.get("ab_update") == "true" |
| 1941 | |
Christian Oder | f63e2cd | 2017-05-01 22:30:15 +0200 | [diff] [blame] | 1942 | # Use the default key to sign the package if not specified with package_key. |
| 1943 | # package_keys are needed on ab_updates, so always define them if an |
| 1944 | # ab_update is getting created. |
| 1945 | if not OPTIONS.no_signing or ab_update: |
| 1946 | if OPTIONS.package_key is None: |
| 1947 | OPTIONS.package_key = OPTIONS.info_dict.get( |
| 1948 | "default_system_dev_certificate", |
| 1949 | "build/target/product/security/testkey") |
| 1950 | # Get signing keys |
| 1951 | OPTIONS.key_passwords = common.GetKeyPasswords([OPTIONS.package_key]) |
| 1952 | |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1953 | if ab_update: |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1954 | WriteABOTAPackageWithBrilloScript( |
| 1955 | target_file=args[0], |
| 1956 | output_file=args[1], |
| 1957 | source_file=OPTIONS.incremental_source) |
| 1958 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1959 | print("done.") |
Tao Bao | c098e9e | 2016-01-07 13:03:56 -0800 | [diff] [blame] | 1960 | return |
| 1961 | |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1962 | # Sanity check the loaded info dicts first. |
| 1963 | if OPTIONS.info_dict.get("no_recovery") == "true": |
| 1964 | raise common.ExternalError( |
| 1965 | "--- target build has specified no recovery ---") |
| 1966 | |
| 1967 | # Non-A/B OTAs rely on /cache partition to store temporary files. |
| 1968 | cache_size = OPTIONS.info_dict.get("cache_size") |
| 1969 | if cache_size is None: |
| 1970 | print("--- can't determine the cache partition size ---") |
| 1971 | OPTIONS.cache_size = cache_size |
| 1972 | |
Doug Zongker | 1c390a2 | 2009-05-14 19:06:36 -0700 | [diff] [blame] | 1973 | if OPTIONS.extra_script is not None: |
| 1974 | OPTIONS.extra_script = open(OPTIONS.extra_script).read() |
| 1975 | |
Dan Willemsen | cea5cd2 | 2017-03-21 14:44:27 -0700 | [diff] [blame] | 1976 | if OPTIONS.extracted_input is not None: |
| 1977 | OPTIONS.input_tmp = OPTIONS.extracted_input |
Dan Willemsen | cea5cd2 | 2017-03-21 14:44:27 -0700 | [diff] [blame] | 1978 | else: |
| 1979 | print("unzipping target target-files...") |
Tao Bao | dba59ee | 2018-01-09 13:21:02 -0800 | [diff] [blame] | 1980 | OPTIONS.input_tmp = common.UnzipTemp(args[0], UNZIP_PATTERN) |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1981 | OPTIONS.target_tmp = OPTIONS.input_tmp |
Doug Zongker | fdd8e69 | 2009-08-03 17:27:48 -0700 | [diff] [blame] | 1982 | |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1983 | # If the caller explicitly specified the device-specific extensions path via |
| 1984 | # -s / --device_specific, use that. Otherwise, use META/releasetools.py if it |
| 1985 | # is present in the target target_files. Otherwise, take the path of the file |
| 1986 | # from 'tool_extensions' in the info dict and look for that in the local |
| 1987 | # filesystem, relative to the current directory. |
Doug Zongker | 3797473 | 2010-09-16 17:44:38 -0700 | [diff] [blame] | 1988 | if OPTIONS.device_specific is None: |
Doug Zongker | eb0a78a | 2014-01-27 10:01:06 -0800 | [diff] [blame] | 1989 | from_input = os.path.join(OPTIONS.input_tmp, "META", "releasetools.py") |
| 1990 | if os.path.exists(from_input): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 1991 | print("(using device-specific extensions from target_files)") |
Doug Zongker | eb0a78a | 2014-01-27 10:01:06 -0800 | [diff] [blame] | 1992 | OPTIONS.device_specific = from_input |
| 1993 | else: |
Tao Bao | 2db1385 | 2018-01-08 22:28:57 -0800 | [diff] [blame] | 1994 | OPTIONS.device_specific = OPTIONS.info_dict.get("tool_extensions") |
Doug Zongker | eb0a78a | 2014-01-27 10:01:06 -0800 | [diff] [blame] | 1995 | |
Doug Zongker | 3797473 | 2010-09-16 17:44:38 -0700 | [diff] [blame] | 1996 | if OPTIONS.device_specific is not None: |
Doug Zongker | eb0a78a | 2014-01-27 10:01:06 -0800 | [diff] [blame] | 1997 | OPTIONS.device_specific = os.path.abspath(OPTIONS.device_specific) |
Doug Zongker | 3797473 | 2010-09-16 17:44:38 -0700 | [diff] [blame] | 1998 | |
Tao Bao | 767e3ac | 2015-11-10 12:19:19 -0800 | [diff] [blame] | 1999 | # Generate a full OTA. |
Tao Bao | 0c6a414 | 2017-12-15 10:11:19 -0800 | [diff] [blame] | 2000 | if OPTIONS.incremental_source is None: |
Tao Bao | dba59ee | 2018-01-09 13:21:02 -0800 | [diff] [blame] | 2001 | with zipfile.ZipFile(args[0], 'r') as input_zip: |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 2002 | WriteFullOTAPackage( |
| 2003 | input_zip, |
| 2004 | output_file=args[1]) |
Tao Bao | 767e3ac | 2015-11-10 12:19:19 -0800 | [diff] [blame] | 2005 | |
Tao Bao | 32b80dc | 2018-01-08 22:50:47 -0800 | [diff] [blame] | 2006 | # Generate an incremental OTA. |
Tao Bao | 767e3ac | 2015-11-10 12:19:19 -0800 | [diff] [blame] | 2007 | else: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 2008 | print("unzipping source target-files...") |
Tao Bao | dba59ee | 2018-01-09 13:21:02 -0800 | [diff] [blame] | 2009 | OPTIONS.source_tmp = common.UnzipTemp( |
| 2010 | OPTIONS.incremental_source, UNZIP_PATTERN) |
| 2011 | with zipfile.ZipFile(args[0], 'r') as input_zip, \ |
| 2012 | zipfile.ZipFile(OPTIONS.incremental_source, 'r') as source_zip: |
Tao Bao | 491d7e2 | 2018-02-21 13:17:22 -0800 | [diff] [blame] | 2013 | WriteBlockIncrementalOTAPackage( |
| 2014 | input_zip, |
| 2015 | source_zip, |
| 2016 | output_file=args[1]) |
Tao Bao | 32b80dc | 2018-01-08 22:50:47 -0800 | [diff] [blame] | 2017 | |
| 2018 | if OPTIONS.log_diff: |
| 2019 | with open(OPTIONS.log_diff, 'w') as out_file: |
Tao Bao | d62c603 | 2015-11-30 09:40:20 -0800 | [diff] [blame] | 2020 | import target_files_diff |
Tao Bao | 32b80dc | 2018-01-08 22:50:47 -0800 | [diff] [blame] | 2021 | target_files_diff.recursiveDiff( |
| 2022 | '', OPTIONS.source_tmp, OPTIONS.input_tmp, out_file) |
Doug Zongker | 62d4f18 | 2014-08-04 16:06:43 -0700 | [diff] [blame] | 2023 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 2024 | print("done.") |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 2025 | |
| 2026 | |
| 2027 | if __name__ == '__main__': |
| 2028 | try: |
Ying Wang | 7e6d4e4 | 2010-12-13 16:25:36 -0800 | [diff] [blame] | 2029 | common.CloseInheritedPipes() |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 2030 | main(sys.argv[1:]) |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 2031 | except common.ExternalError as e: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 2032 | print("\n ERROR: %s\n" % (e,)) |
Doug Zongker | eef3944 | 2009-04-02 12:14:19 -0700 | [diff] [blame] | 2033 | sys.exit(1) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 2034 | finally: |
| 2035 | common.Cleanup() |