Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 1 | # Copyright (C) 2009 The Android Open Source Project |
| 2 | # |
| 3 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | # you may not use this file except in compliance with the License. |
| 5 | # You may obtain a copy of the License at |
| 6 | # |
| 7 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | # |
| 9 | # Unless required by applicable law or agreed to in writing, software |
| 10 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | # See the License for the specific language governing permissions and |
| 13 | # limitations under the License. |
| 14 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 15 | import re |
| 16 | |
| 17 | import common |
| 18 | |
| 19 | class EdifyGenerator(object): |
| 20 | """Class to generate scripts in the 'edify' recovery script language |
| 21 | used from donut onwards.""" |
| 22 | |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 23 | def __init__(self, version, info, fstab=None): |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 24 | self.script = [] |
| 25 | self.mounts = set() |
Tao Bao | b4cfca5 | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 26 | self._required_cache = 0 |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 27 | self.version = version |
Doug Zongker | b4c7d32 | 2010-07-01 15:30:11 -0700 | [diff] [blame] | 28 | self.info = info |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 29 | if fstab is None: |
| 30 | self.fstab = self.info.get("fstab", None) |
| 31 | else: |
| 32 | self.fstab = fstab |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 33 | |
| 34 | def MakeTemporary(self): |
| 35 | """Make a temporary script object whose commands can latter be |
| 36 | appended to the parent script with AppendScript(). Used when the |
| 37 | caller wants to generate script commands out-of-order.""" |
Doug Zongker | 6736998 | 2010-07-07 13:53:32 -0700 | [diff] [blame] | 38 | x = EdifyGenerator(self.version, self.info) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 39 | x.mounts = self.mounts |
| 40 | return x |
| 41 | |
Tao Bao | b4cfca5 | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 42 | @property |
| 43 | def required_cache(self): |
| 44 | """Return the minimum cache size to apply the update.""" |
| 45 | return self._required_cache |
| 46 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 47 | @staticmethod |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 48 | def WordWrap(cmd, linelen=80): |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 49 | """'cmd' should be a function call with null characters after each |
| 50 | parameter (eg, "somefun(foo,\0bar,\0baz)"). This function wraps cmd |
| 51 | to a given line length, replacing nulls with spaces and/or newlines |
| 52 | to format it nicely.""" |
| 53 | indent = cmd.index("(")+1 |
| 54 | out = [] |
| 55 | first = True |
| 56 | x = re.compile("^(.{,%d})\0" % (linelen-indent,)) |
| 57 | while True: |
| 58 | if not first: |
| 59 | out.append(" " * indent) |
| 60 | first = False |
| 61 | m = x.search(cmd) |
| 62 | if not m: |
| 63 | parts = cmd.split("\0", 1) |
| 64 | out.append(parts[0]+"\n") |
| 65 | if len(parts) == 1: |
| 66 | break |
| 67 | else: |
| 68 | cmd = parts[1] |
| 69 | continue |
| 70 | out.append(m.group(1)+"\n") |
| 71 | cmd = cmd[m.end():] |
| 72 | |
| 73 | return "".join(out).replace("\0", " ").rstrip("\n") |
| 74 | |
| 75 | def AppendScript(self, other): |
| 76 | """Append the contents of another script (which should be created |
| 77 | with temporary=True) to this one.""" |
| 78 | self.script.extend(other.script) |
| 79 | |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 80 | def AssertOemProperty(self, name, value): |
| 81 | """Assert that a property on the OEM paritition matches a value.""" |
| 82 | if not name: |
| 83 | raise ValueError("must specify an OEM property") |
| 84 | if not value: |
| 85 | raise ValueError("must specify the OEM value") |
Tao Bao | df4cb0b | 2016-02-25 19:49:55 -0800 | [diff] [blame] | 86 | if common.OPTIONS.oem_no_mount: |
| 87 | cmd = ('getprop("{name}") == "{value}" || ' |
| 88 | 'abort("This package expects the value \\"{value}\\" for ' |
| 89 | '\\"{name}\\"; this has value \\"" + ' |
| 90 | 'getprop("{name}") + "\\".");').format(name=name, value=value) |
| 91 | else: |
| 92 | cmd = ('file_getprop("/oem/oem.prop", "{name}") == "{value}" || ' |
| 93 | 'abort("This package expects the value \\"{value}\\" for ' |
| 94 | '\\"{name}\\" on the OEM partition; this has value \\"" + ' |
| 95 | 'file_getprop("/oem/oem.prop", "{name}") + "\\".");').format( |
| 96 | name=name, value=value) |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 97 | self.script.append(cmd) |
| 98 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 99 | def AssertSomeFingerprint(self, *fp): |
Doug Zongker | af84525 | 2014-05-09 08:29:05 -0700 | [diff] [blame] | 100 | """Assert that the current recovery build fingerprint is one of *fp.""" |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 101 | if not fp: |
| 102 | raise ValueError("must specify some fingerprints") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 103 | cmd = (' ||\n '.join([('getprop("ro.build.fingerprint") == "%s"') % i |
| 104 | for i in fp]) + |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 105 | ' ||\n abort("Package expects build fingerprint of %s; this ' |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 106 | 'device has " + getprop("ro.build.fingerprint") + ".");') % ( |
| 107 | " or ".join(fp)) |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 108 | self.script.append(cmd) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 109 | |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 110 | def AssertSomeThumbprint(self, *fp): |
Doug Zongker | af84525 | 2014-05-09 08:29:05 -0700 | [diff] [blame] | 111 | """Assert that the current recovery build thumbprint is one of *fp.""" |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 112 | if not fp: |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 113 | raise ValueError("must specify some thumbprints") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 114 | cmd = (' ||\n '.join([('getprop("ro.build.thumbprint") == "%s"') % i |
| 115 | for i in fp]) + |
Michael Runge | 6e83611 | 2014-04-15 17:40:21 -0700 | [diff] [blame] | 116 | ' ||\n abort("Package expects build thumbprint of %s; this ' |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 117 | 'device has " + getprop("ro.build.thumbprint") + ".");') % ( |
| 118 | " or ".join(fp)) |
Geremy Condra | 36bd365 | 2014-02-06 19:45:10 -0800 | [diff] [blame] | 119 | self.script.append(cmd) |
| 120 | |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 121 | def AssertOlderBuild(self, timestamp, timestamp_text): |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 122 | """Assert that the build on the device is older (or the same as) |
| 123 | the given timestamp.""" |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 124 | self.script.append( |
| 125 | ('(!less_than_int(%s, getprop("ro.build.date.utc"))) || ' |
| 126 | 'abort("Can\'t install this package (%s) over newer ' |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 127 | 'build (" + getprop("ro.build.date") + ").");') % (timestamp, |
| 128 | timestamp_text)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 129 | |
| 130 | def AssertDevice(self, device): |
| 131 | """Assert that the device identifier is the given string.""" |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 132 | cmd = ('getprop("ro.product.device") == "%s" || ' |
| 133 | 'abort("This package is for \\"%s\\" devices; ' |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 134 | 'this is a \\"" + getprop("ro.product.device") + "\\".");') % ( |
| 135 | device, device) |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 136 | self.script.append(cmd) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 137 | |
| 138 | def AssertSomeBootloader(self, *bootloaders): |
| 139 | """Asert that the bootloader version is one of *bootloaders.""" |
| 140 | cmd = ("assert(" + |
| 141 | " ||\0".join(['getprop("ro.bootloader") == "%s"' % (b,) |
| 142 | for b in bootloaders]) + |
| 143 | ");") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 144 | self.script.append(self.WordWrap(cmd)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 145 | |
| 146 | def ShowProgress(self, frac, dur): |
| 147 | """Update the progress bar, advancing it over 'frac' over the next |
Doug Zongker | 881dd40 | 2009-09-20 14:03:55 -0700 | [diff] [blame] | 148 | 'dur' seconds. 'dur' may be zero to advance it via SetProgress |
| 149 | commands instead of by time.""" |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 150 | self.script.append("show_progress(%f, %d);" % (frac, int(dur))) |
| 151 | |
Doug Zongker | 881dd40 | 2009-09-20 14:03:55 -0700 | [diff] [blame] | 152 | def SetProgress(self, frac): |
| 153 | """Set the position of the progress bar within the chunk defined |
| 154 | by the most recent ShowProgress call. 'frac' should be in |
| 155 | [0,1].""" |
| 156 | self.script.append("set_progress(%f);" % (frac,)) |
| 157 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 158 | def PatchCheck(self, filename, *sha1): |
| 159 | """Check that the given file (or MTD reference) has one of the |
Doug Zongker | c8d446b | 2010-02-22 15:41:53 -0800 | [diff] [blame] | 160 | given *sha1 hashes, checking the version saved in cache if the |
| 161 | file does not match.""" |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 162 | self.script.append( |
| 163 | 'apply_patch_check("%s"' % (filename,) + |
| 164 | "".join([', "%s"' % (i,) for i in sha1]) + |
| 165 | ') || abort("\\"%s\\" has unexpected contents.");' % (filename,)) |
Doug Zongker | c8d446b | 2010-02-22 15:41:53 -0800 | [diff] [blame] | 166 | |
Tao Bao | 9bc6bb2 | 2015-11-09 16:58:28 -0800 | [diff] [blame] | 167 | def Verify(self, filename): |
| 168 | """Check that the given file (or MTD reference) has one of the |
| 169 | given hashes (encoded in the filename).""" |
| 170 | self.script.append( |
| 171 | 'apply_patch_check("{filename}") && ' |
| 172 | 'ui_print(" Verified.") || ' |
| 173 | 'ui_print("\\"{filename}\\" has unexpected contents.");'.format( |
| 174 | filename=filename)) |
| 175 | |
Doug Zongker | c8d446b | 2010-02-22 15:41:53 -0800 | [diff] [blame] | 176 | def FileCheck(self, filename, *sha1): |
| 177 | """Check that the given file (or MTD reference) has one of the |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 178 | given *sha1 hashes.""" |
Doug Zongker | 5a48209 | 2010-02-17 16:09:18 -0800 | [diff] [blame] | 179 | self.script.append('assert(sha1_check(read_file("%s")' % (filename,) + |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 180 | "".join([', "%s"' % (i,) for i in sha1]) + |
| 181 | '));') |
| 182 | |
| 183 | def CacheFreeSpaceCheck(self, amount): |
| 184 | """Check that there's at least 'amount' space that can be made |
| 185 | available on /cache.""" |
Tao Bao | b4cfca5 | 2016-02-04 14:26:02 -0800 | [diff] [blame] | 186 | self._required_cache = max(self._required_cache, amount) |
Doug Zongker | 0d92f1f | 2013-06-03 12:07:12 -0700 | [diff] [blame] | 187 | self.script.append(('apply_patch_space(%d) || abort("Not enough free space ' |
Tao Bao | e7b1037 | 2015-06-03 09:24:08 -0700 | [diff] [blame] | 188 | 'on /cache to apply patches.");') % (amount,)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 189 | |
Michael Runge | 7cd99ba | 2014-10-22 17:21:48 -0700 | [diff] [blame] | 190 | def Mount(self, mount_point, mount_options_by_format=""): |
| 191 | """Mount the partition with the given mount_point. |
| 192 | mount_options_by_format: |
| 193 | [fs_type=option[,option]...[|fs_type=option[,option]...]...] |
| 194 | where option is optname[=optvalue] |
| 195 | E.g. ext4=barrier=1,nodelalloc,errors=panic|f2fs=errors=recover |
| 196 | """ |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 197 | fstab = self.fstab |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 198 | if fstab: |
| 199 | p = fstab[mount_point] |
Michael Runge | 7cd99ba | 2014-10-22 17:21:48 -0700 | [diff] [blame] | 200 | mount_dict = {} |
| 201 | if mount_options_by_format is not None: |
| 202 | for option in mount_options_by_format.split("|"): |
| 203 | if "=" in option: |
| 204 | key, value = option.split("=", 1) |
| 205 | mount_dict[key] = value |
Tao Bao | df06e96 | 2015-06-10 12:32:41 -0700 | [diff] [blame] | 206 | mount_flags = mount_dict.get(p.fs_type, "") |
| 207 | if p.context is not None: |
| 208 | mount_flags = p.context + ("," + mount_flags if mount_flags else "") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 209 | self.script.append('mount("%s", "%s", "%s", "%s", "%s");' % ( |
| 210 | p.fs_type, common.PARTITION_TYPES[p.fs_type], p.device, |
Tao Bao | df06e96 | 2015-06-10 12:32:41 -0700 | [diff] [blame] | 211 | p.mount_point, mount_flags)) |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 212 | self.mounts.add(p.mount_point) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 213 | |
| 214 | def UnpackPackageDir(self, src, dst): |
| 215 | """Unpack a given directory from the OTA package into the given |
| 216 | destination directory.""" |
| 217 | self.script.append('package_extract_dir("%s", "%s");' % (src, dst)) |
| 218 | |
| 219 | def Comment(self, comment): |
| 220 | """Write a comment into the update script.""" |
| 221 | self.script.append("") |
| 222 | for i in comment.split("\n"): |
| 223 | self.script.append("# " + i) |
| 224 | self.script.append("") |
| 225 | |
| 226 | def Print(self, message): |
| 227 | """Log a message to the screen (if the logs are visible).""" |
| 228 | self.script.append('ui_print("%s");' % (message,)) |
| 229 | |
Michael Runge | 3e28664 | 2014-11-21 00:46:03 -0800 | [diff] [blame] | 230 | def TunePartition(self, partition, *options): |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 231 | fstab = self.fstab |
Michael Runge | 3e28664 | 2014-11-21 00:46:03 -0800 | [diff] [blame] | 232 | if fstab: |
| 233 | p = fstab[partition] |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 234 | if p.fs_type not in ("ext2", "ext3", "ext4"): |
Michael Runge | 3e28664 | 2014-11-21 00:46:03 -0800 | [diff] [blame] | 235 | raise ValueError("Partition %s cannot be tuned\n" % (partition,)) |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 236 | self.script.append( |
| 237 | 'tune2fs(' + "".join(['"%s", ' % (i,) for i in options]) + |
| 238 | '"%s") || abort("Failed to tune partition %s");' % ( |
| 239 | p.device, partition)) |
Michael Runge | 3e28664 | 2014-11-21 00:46:03 -0800 | [diff] [blame] | 240 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 241 | def FormatPartition(self, partition): |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 242 | """Format the given partition, specified by its mount point (eg, |
| 243 | "/system").""" |
| 244 | |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 245 | fstab = self.fstab |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 246 | if fstab: |
| 247 | p = fstab[partition] |
Doug Zongker | df2056e | 2012-04-09 12:27:43 -0700 | [diff] [blame] | 248 | self.script.append('format("%s", "%s", "%s", "%s", "%s");' % |
Doug Zongker | 086cbb0 | 2011-02-17 15:54:20 -0800 | [diff] [blame] | 249 | (p.fs_type, common.PARTITION_TYPES[p.fs_type], |
Doug Zongker | df2056e | 2012-04-09 12:27:43 -0700 | [diff] [blame] | 250 | p.device, p.length, p.mount_point)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 251 | |
Doug Zongker | 5fad203 | 2014-02-24 08:13:45 -0800 | [diff] [blame] | 252 | def WipeBlockDevice(self, partition): |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 253 | if partition not in ("/system", "/vendor"): |
| 254 | raise ValueError(("WipeBlockDevice doesn't work on %s\n") % (partition,)) |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 255 | fstab = self.fstab |
Doug Zongker | c8b4e84 | 2014-06-16 15:16:31 -0700 | [diff] [blame] | 256 | size = self.info.get(partition.lstrip("/") + "_size", None) |
Doug Zongker | 5fad203 | 2014-02-24 08:13:45 -0800 | [diff] [blame] | 257 | device = fstab[partition].device |
| 258 | |
| 259 | self.script.append('wipe_block_device("%s", %s);' % (device, size)) |
| 260 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 261 | def DeleteFiles(self, file_list): |
| 262 | """Delete all files in file_list.""" |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 263 | if not file_list: |
| 264 | return |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 265 | cmd = "delete(" + ",\0".join(['"%s"' % (i,) for i in file_list]) + ");" |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 266 | self.script.append(self.WordWrap(cmd)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 267 | |
Tao Bao | 84006ea | 2015-09-02 10:28:08 -0700 | [diff] [blame] | 268 | def DeleteFilesIfNotMatching(self, file_list): |
| 269 | """Delete the file in file_list if not matching the checksum.""" |
| 270 | if not file_list: |
| 271 | return |
| 272 | for name, sha1 in file_list: |
| 273 | cmd = ('sha1_check(read_file("{name}"), "{sha1}") || ' |
| 274 | 'delete("{name}");'.format(name=name, sha1=sha1)) |
| 275 | self.script.append(self.WordWrap(cmd)) |
| 276 | |
Michael Runge | 4038aa8 | 2013-12-13 18:06:28 -0800 | [diff] [blame] | 277 | def RenameFile(self, srcfile, tgtfile): |
| 278 | """Moves a file from one location to another.""" |
| 279 | if self.info.get("update_rename_support", False): |
| 280 | self.script.append('rename("%s", "%s");' % (srcfile, tgtfile)) |
| 281 | else: |
| 282 | raise ValueError("Rename not supported by update binary") |
| 283 | |
| 284 | def SkipNextActionIfTargetExists(self, tgtfile, tgtsha1): |
| 285 | """Prepend an action with an apply_patch_check in order to |
| 286 | skip the action if the file exists. Used when a patch |
| 287 | is later renamed.""" |
Tao Bao | 84006ea | 2015-09-02 10:28:08 -0700 | [diff] [blame] | 288 | cmd = ('sha1_check(read_file("%s"), %s) ||' % (tgtfile, tgtsha1)) |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 289 | self.script.append(self.WordWrap(cmd)) |
Michael Runge | 4038aa8 | 2013-12-13 18:06:28 -0800 | [diff] [blame] | 290 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 291 | def ApplyPatch(self, srcfile, tgtfile, tgtsize, tgtsha1, *patchpairs): |
| 292 | """Apply binary patches (in *patchpairs) to the given srcfile to |
| 293 | produce tgtfile (which may be "-" to indicate overwriting the |
| 294 | source file.""" |
| 295 | if len(patchpairs) % 2 != 0 or len(patchpairs) == 0: |
| 296 | raise ValueError("bad patches given to ApplyPatch") |
| 297 | cmd = ['apply_patch("%s",\0"%s",\0%s,\0%d' |
| 298 | % (srcfile, tgtfile, tgtsha1, tgtsize)] |
| 299 | for i in range(0, len(patchpairs), 2): |
Tao Bao | c386890 | 2015-12-01 17:46:46 -0800 | [diff] [blame] | 300 | cmd.append(',\0%s,\0package_extract_file("%s")' % patchpairs[i:i+2]) |
| 301 | cmd.append(') ||\n abort("Failed to apply patch to %s");' % (srcfile,)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 302 | cmd = "".join(cmd) |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 303 | self.script.append(self.WordWrap(cmd)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 304 | |
Doug Zongker | 5fad203 | 2014-02-24 08:13:45 -0800 | [diff] [blame] | 305 | def WriteRawImage(self, mount_point, fn, mapfn=None): |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 306 | """Write the given package file into the partition for the given |
| 307 | mount point.""" |
Doug Zongker | b4c7d32 | 2010-07-01 15:30:11 -0700 | [diff] [blame] | 308 | |
Tao Bao | 34b47bf | 2015-06-22 19:17:41 -0700 | [diff] [blame] | 309 | fstab = self.fstab |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 310 | if fstab: |
| 311 | p = fstab[mount_point] |
Doug Zongker | 96a57e7 | 2010-09-26 14:57:41 -0700 | [diff] [blame] | 312 | partition_type = common.PARTITION_TYPES[p.fs_type] |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 313 | args = {'device': p.device, 'fn': fn} |
| 314 | if partition_type == "MTD": |
| 315 | self.script.append( |
Doug Zongker | 02da210 | 2011-04-12 15:50:17 -0700 | [diff] [blame] | 316 | 'write_raw_image(package_extract_file("%(fn)s"), "%(device)s");' |
| 317 | % args) |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 318 | elif partition_type == "EMMC": |
Doug Zongker | 5fad203 | 2014-02-24 08:13:45 -0800 | [diff] [blame] | 319 | if mapfn: |
| 320 | args["map"] = mapfn |
| 321 | self.script.append( |
| 322 | 'package_extract_file("%(fn)s", "%(device)s", "%(map)s");' % args) |
| 323 | else: |
| 324 | self.script.append( |
| 325 | 'package_extract_file("%(fn)s", "%(device)s");' % args) |
Doug Zongker | 9ce0fb6 | 2010-09-20 18:04:41 -0700 | [diff] [blame] | 326 | else: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 327 | raise ValueError( |
| 328 | "don't know how to write \"%s\" partitions" % p.fs_type) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 329 | |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 330 | def SetPermissions(self, fn, uid, gid, mode, selabel, capabilities): |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 331 | """Set file ownership and permissions.""" |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 332 | if not self.info.get("use_set_metadata", False): |
| 333 | self.script.append('set_perm(%d, %d, 0%o, "%s");' % (uid, gid, mode, fn)) |
| 334 | else: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 335 | if capabilities is None: |
| 336 | capabilities = "0x0" |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 337 | cmd = 'set_metadata("%s", "uid", %d, "gid", %d, "mode", 0%o, ' \ |
| 338 | '"capabilities", %s' % (fn, uid, gid, mode, capabilities) |
| 339 | if selabel is not None: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 340 | cmd += ', "selabel", "%s"' % selabel |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 341 | cmd += ');' |
| 342 | self.script.append(cmd) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 343 | |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 344 | def SetPermissionsRecursive(self, fn, uid, gid, dmode, fmode, selabel, |
| 345 | capabilities): |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 346 | """Recursively set path ownership and permissions.""" |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 347 | if not self.info.get("use_set_metadata", False): |
| 348 | self.script.append('set_perm_recursive(%d, %d, 0%o, 0%o, "%s");' |
| 349 | % (uid, gid, dmode, fmode, fn)) |
| 350 | else: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 351 | if capabilities is None: |
| 352 | capabilities = "0x0" |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 353 | cmd = 'set_metadata_recursive("%s", "uid", %d, "gid", %d, ' \ |
| 354 | '"dmode", 0%o, "fmode", 0%o, "capabilities", %s' \ |
| 355 | % (fn, uid, gid, dmode, fmode, capabilities) |
| 356 | if selabel is not None: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 357 | cmd += ', "selabel", "%s"' % selabel |
Nick Kralevich | 0eb17d9 | 2013-09-07 17:10:29 -0700 | [diff] [blame] | 358 | cmd += ');' |
| 359 | self.script.append(cmd) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 360 | |
| 361 | def MakeSymlinks(self, symlink_list): |
| 362 | """Create symlinks, given a list of (dest, link) pairs.""" |
| 363 | by_dest = {} |
| 364 | for d, l in symlink_list: |
| 365 | by_dest.setdefault(d, []).append(l) |
| 366 | |
| 367 | for dest, links in sorted(by_dest.iteritems()): |
| 368 | cmd = ('symlink("%s", ' % (dest,) + |
| 369 | ",\0".join(['"' + i + '"' for i in sorted(links)]) + ");") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 370 | self.script.append(self.WordWrap(cmd)) |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 371 | |
| 372 | def AppendExtra(self, extra): |
| 373 | """Append text verbatim to the output script.""" |
| 374 | self.script.append(extra) |
| 375 | |
Michael Runge | 63f01de | 2014-10-28 19:24:19 -0700 | [diff] [blame] | 376 | def Unmount(self, mount_point): |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 377 | self.script.append('unmount("%s");' % mount_point) |
| 378 | self.mounts.remove(mount_point) |
Michael Runge | 63f01de | 2014-10-28 19:24:19 -0700 | [diff] [blame] | 379 | |
Doug Zongker | 1483360 | 2010-02-02 13:12:04 -0800 | [diff] [blame] | 380 | def UnmountAll(self): |
| 381 | for p in sorted(self.mounts): |
| 382 | self.script.append('unmount("%s");' % (p,)) |
| 383 | self.mounts = set() |
| 384 | |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 385 | def AddToZip(self, input_zip, output_zip, input_path=None): |
| 386 | """Write the accumulated script to the output_zip file. input_zip |
| 387 | is used as the source for the 'updater' binary needed to run |
| 388 | script. If input_path is not None, it will be used as a local |
| 389 | path for the binary instead of input_zip.""" |
| 390 | |
Doug Zongker | 1483360 | 2010-02-02 13:12:04 -0800 | [diff] [blame] | 391 | self.UnmountAll() |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 392 | |
| 393 | common.ZipWriteStr(output_zip, "META-INF/com/google/android/updater-script", |
| 394 | "\n".join(self.script) + "\n") |
| 395 | |
| 396 | if input_path is None: |
| 397 | data = input_zip.read("OTA/bin/updater") |
| 398 | else: |
Doug Zongker | 2556848 | 2014-03-03 10:21:27 -0800 | [diff] [blame] | 399 | data = open(input_path, "rb").read() |
Doug Zongker | c494d7c | 2009-06-18 08:43:44 -0700 | [diff] [blame] | 400 | common.ZipWriteStr(output_zip, "META-INF/com/google/android/update-binary", |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 401 | data, perms=0o755) |