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 """ 18 Given a target-files zipfile, produces an OTA package that installs 19 that build. An incremental OTA is produced if -i is given, otherwise 20 a full OTA is produced. 21 22 Usage: ota_from_target_files [flags] input_target_files output_ota_package 23 24 -b (--board_config) <file> 25 Deprecated. 26 27 -k (--package_key) <key> 28 Key to use to sign the package (default is 29 "build/target/product/security/testkey"). 30 31 -i (--incremental_from) <file> 32 Generate an incremental OTA using the given target-files zip as 33 the starting build. 34 35 -w (--wipe_user_data) 36 Generate an OTA package that will wipe the user data partition 37 when installed. 38 39 -n (--no_prereq) 40 Omit the timestamp prereq check normally included at the top of 41 the build scripts (used for developer OTA packages which 42 legitimately need to go back and forth). 43 44 -e (--extra_script) <file> 45 Insert the contents of file at the end of the update script. 46 47 -m (--script_mode) <mode> 48 Specify 'amend' or 'edify' scripts, or 'auto' to pick 49 automatically (this is the default). 50 51 """ 52 53 import sys 54 55 if sys.hexversion < 0x02040000: 56 print >> sys.stderr, "Python 2.4 or newer is required." 57 sys.exit(1) 58 59 import copy 60 import errno 61 import os 62 import re 63 import sha 64 import subprocess 65 import tempfile 66 import threading 67 import time 68 import zipfile 69 70 import common 71 import amend_generator 72 import edify_generator 73 import both_generator 74 75 OPTIONS = common.OPTIONS 76 OPTIONS.package_key = "build/target/product/security/testkey" 77 OPTIONS.incremental_source = None 78 OPTIONS.require_verbatim = set() 79 OPTIONS.prohibit_verbatim = set(("system/build.prop",)) 80 OPTIONS.patch_threshold = 0.95 81 OPTIONS.wipe_user_data = False 82 OPTIONS.omit_prereq = False 83 OPTIONS.extra_script = None 84 OPTIONS.script_mode = 'auto' 85 OPTIONS.worker_threads = 3 86 87 def MostPopularKey(d, default): 88 """Given a dict, return the key corresponding to the largest 89 value. Returns 'default' if the dict is empty.""" 90 x = [(v, k) for (k, v) in d.iteritems()] 91 if not x: return default 92 x.sort() 93 return x[-1][1] 94 95 96 def IsSymlink(info): 97 """Return true if the zipfile.ZipInfo object passed in represents a 98 symlink.""" 99 return (info.external_attr >> 16) == 0120777 100 101 102 103 class Item: 104 """Items represent the metadata (user, group, mode) of files and 105 directories in the system image.""" 106 ITEMS = {} 107 def __init__(self, name, dir=False): 108 self.name = name 109 self.uid = None 110 self.gid = None 111 self.mode = None 112 self.dir = dir 113 114 if name: 115 self.parent = Item.Get(os.path.dirname(name), dir=True) 116 self.parent.children.append(self) 117 else: 118 self.parent = None 119 if dir: 120 self.children = [] 121 122 def Dump(self, indent=0): 123 if self.uid is not None: 124 print "%s%s %d %d %o" % (" "*indent, self.name, self.uid, self.gid, self.mode) 125 else: 126 print "%s%s %s %s %s" % (" "*indent, self.name, self.uid, self.gid, self.mode) 127 if self.dir: 128 print "%s%s" % (" "*indent, self.descendants) 129 print "%s%s" % (" "*indent, self.best_subtree) 130 for i in self.children: 131 i.Dump(indent=indent+1) 132 133 @classmethod 134 def Get(cls, name, dir=False): 135 if name not in cls.ITEMS: 136 cls.ITEMS[name] = Item(name, dir=dir) 137 return cls.ITEMS[name] 138 139 @classmethod 140 def GetMetadata(cls, input_zip): 141 142 try: 143 # See if the target_files contains a record of what the uid, 144 # gid, and mode is supposed to be. 145 output = input_zip.read("META/filesystem_config.txt") 146 except KeyError: 147 # Run the external 'fs_config' program to determine the desired 148 # uid, gid, and mode for every Item object. Note this uses the 149 # one in the client now, which might not be the same as the one 150 # used when this target_files was built. 151 p = common.Run(["fs_config"], stdin=subprocess.PIPE, 152 stdout=subprocess.PIPE, stderr=subprocess.PIPE) 153 suffix = { False: "", True: "/" } 154 input = "".join(["%s%s\n" % (i.name, suffix[i.dir]) 155 for i in cls.ITEMS.itervalues() if i.name]) 156 output, error = p.communicate(input) 157 assert not error 158 159 for line in output.split("\n"): 160 if not line: continue 161 name, uid, gid, mode = line.split() 162 i = cls.ITEMS.get(name, None) 163 if i is not None: 164 i.uid = int(uid) 165 i.gid = int(gid) 166 i.mode = int(mode, 8) 167 if i.dir: 168 i.children.sort(key=lambda i: i.name) 169 170 # set metadata for the files generated by this script. 171 i = cls.ITEMS.get("system/recovery-from-boot.p", None) 172 if i: i.uid, i.gid, i.mode = 0, 0, 0644 173 i = cls.ITEMS.get("system/etc/install-recovery.sh", None) 174 if i: i.uid, i.gid, i.mode = 0, 0, 0544 175 176 def CountChildMetadata(self): 177 """Count up the (uid, gid, mode) tuples for all children and 178 determine the best strategy for using set_perm_recursive and 179 set_perm to correctly chown/chmod all the files to their desired 180 values. Recursively calls itself for all descendants. 181 182 Returns a dict of {(uid, gid, dmode, fmode): count} counting up 183 all descendants of this node. (dmode or fmode may be None.) Also 184 sets the best_subtree of each directory Item to the (uid, gid, 185 dmode, fmode) tuple that will match the most descendants of that 186 Item. 187 """ 188 189 assert self.dir 190 d = self.descendants = {(self.uid, self.gid, self.mode, None): 1} 191 for i in self.children: 192 if i.dir: 193 for k, v in i.CountChildMetadata().iteritems(): 194 d[k] = d.get(k, 0) + v 195 else: 196 k = (i.uid, i.gid, None, i.mode) 197 d[k] = d.get(k, 0) + 1 198 199 # Find the (uid, gid, dmode, fmode) tuple that matches the most 200 # descendants. 201 202 # First, find the (uid, gid) pair that matches the most 203 # descendants. 204 ug = {} 205 for (uid, gid, _, _), count in d.iteritems(): 206 ug[(uid, gid)] = ug.get((uid, gid), 0) + count 207 ug = MostPopularKey(ug, (0, 0)) 208 209 # Now find the dmode and fmode that match the most descendants 210 # with that (uid, gid), and choose those. 211 best_dmode = (0, 0755) 212 best_fmode = (0, 0644) 213 for k, count in d.iteritems(): 214 if k[:2] != ug: continue 215 if k[2] is not None and count >= best_dmode[0]: best_dmode = (count, k[2]) 216 if k[3] is not None and count >= best_fmode[0]: best_fmode = (count, k[3]) 217 self.best_subtree = ug + (best_dmode[1], best_fmode[1]) 218 219 return d 220 221 def SetPermissions(self, script): 222 """Append set_perm/set_perm_recursive commands to 'script' to 223 set all permissions, users, and groups for the tree of files 224 rooted at 'self'.""" 225 226 self.CountChildMetadata() 227 228 def recurse(item, current): 229 # current is the (uid, gid, dmode, fmode) tuple that the current 230 # item (and all its children) have already been set to. We only 231 # need to issue set_perm/set_perm_recursive commands if we're 232 # supposed to be something different. 233 if item.dir: 234 if current != item.best_subtree: 235 script.SetPermissionsRecursive("/"+item.name, *item.best_subtree) 236 current = item.best_subtree 237 238 if item.uid != current[0] or item.gid != current[1] or \ 239 item.mode != current[2]: 240 script.SetPermissions("/"+item.name, item.uid, item.gid, item.mode) 241 242 for i in item.children: 243 recurse(i, current) 244 else: 245 if item.uid != current[0] or item.gid != current[1] or \ 246 item.mode != current[3]: 247 script.SetPermissions("/"+item.name, item.uid, item.gid, item.mode) 248 249 recurse(self, (-1, -1, -1, -1)) 250 251 252 def CopySystemFiles(input_zip, output_zip=None, 253 substitute=None): 254 """Copies files underneath system/ in the input zip to the output 255 zip. Populates the Item class with their metadata, and returns a 256 list of symlinks. output_zip may be None, in which case the copy is 257 skipped (but the other side effects still happen). substitute is an 258 optional dict of {output filename: contents} to be output instead of 259 certain input files. 260 """ 261 262 symlinks = [] 263 264 for info in input_zip.infolist(): 265 if info.filename.startswith("SYSTEM/"): 266 basefilename = info.filename[7:] 267 if IsSymlink(info): 268 symlinks.append((input_zip.read(info.filename), 269 "/system/" + basefilename)) 270 else: 271 info2 = copy.copy(info) 272 fn = info2.filename = "system/" + basefilename 273 if substitute and fn in substitute and substitute[fn] is None: 274 continue 275 if output_zip is not None: 276 if substitute and fn in substitute: 277 data = substitute[fn] 278 else: 279 data = input_zip.read(info.filename) 280 output_zip.writestr(info2, data) 281 if fn.endswith("/"): 282 Item.Get(fn[:-1], dir=True) 283 else: 284 Item.Get(fn, dir=False) 285 286 symlinks.sort() 287 return symlinks 288 289 290 def SignOutput(temp_zip_name, output_zip_name): 291 key_passwords = common.GetKeyPasswords([OPTIONS.package_key]) 292 pw = key_passwords[OPTIONS.package_key] 293 294 common.SignFile(temp_zip_name, output_zip_name, OPTIONS.package_key, pw, 295 whole_file=True) 296 297 298 def AppendAssertions(script, input_zip): 299 device = GetBuildProp("ro.product.device", input_zip) 300 script.AssertDevice(device) 301 302 303 def MakeRecoveryPatch(output_zip, recovery_img, boot_img): 304 """Generate a binary patch that creates the recovery image starting 305 with the boot image. (Most of the space in these images is just the 306 kernel, which is identical for the two, so the resulting patch 307 should be efficient.) Add it to the output zip, along with a shell 308 script that is run from init.rc on first boot to actually do the 309 patching and install the new recovery image. 310 311 recovery_img and boot_img should be File objects for the 312 corresponding images. 313 314 Returns an Item for the shell script, which must be made 315 executable. 316 """ 317 318 d = Difference(recovery_img, boot_img) 319 _, _, patch = d.ComputePatch() 320 common.ZipWriteStr(output_zip, "recovery/recovery-from-boot.p", patch) 321 Item.Get("system/recovery-from-boot.p", dir=False) 322 323 # Images with different content will have a different first page, so 324 # we check to see if this recovery has already been installed by 325 # testing just the first 2k. 326 HEADER_SIZE = 2048 327 header_sha1 = sha.sha(recovery_img.data[:HEADER_SIZE]).hexdigest() 328 sh = """#!/system/bin/sh 329 if ! applypatch -c MTD:recovery:%(header_size)d:%(header_sha1)s; then 330 log -t recovery "Installing new recovery image" 331 applypatch MTD:boot:%(boot_size)d:%(boot_sha1)s MTD:recovery %(recovery_sha1)s %(recovery_size)d %(boot_sha1)s:/system/recovery-from-boot.p 332 else 333 log -t recovery "Recovery image already installed" 334 fi 335 """ % { 'boot_size': boot_img.size, 336 'boot_sha1': boot_img.sha1, 337 'header_size': HEADER_SIZE, 338 'header_sha1': header_sha1, 339 'recovery_size': recovery_img.size, 340 'recovery_sha1': recovery_img.sha1 } 341 common.ZipWriteStr(output_zip, "recovery/etc/install-recovery.sh", sh) 342 return Item.Get("system/etc/install-recovery.sh", dir=False) 343 344 345 def WriteFullOTAPackage(input_zip, output_zip): 346 if OPTIONS.script_mode == "auto": 347 script = both_generator.BothGenerator(2) 348 elif OPTIONS.script_mode == "amend": 349 script = amend_generator.AmendGenerator() 350 else: 351 # TODO: how to determine this? We don't know what version it will 352 # be installed on top of. For now, we expect the API just won't 353 # change very often. 354 script = edify_generator.EdifyGenerator(2) 355 356 metadata = {"post-build": GetBuildProp("ro.build.fingerprint", input_zip), 357 "pre-device": GetBuildProp("ro.product.device", input_zip), 358 } 359 360 device_specific = common.DeviceSpecificParams( 361 input_zip=input_zip, 362 input_version=GetRecoveryAPIVersion(input_zip), 363 output_zip=output_zip, 364 script=script, 365 input_tmp=OPTIONS.input_tmp, 366 metadata=metadata) 367 368 if not OPTIONS.omit_prereq: 369 ts = GetBuildProp("ro.build.date.utc", input_zip) 370 script.AssertOlderBuild(ts) 371 372 AppendAssertions(script, input_zip) 373 device_specific.FullOTA_Assertions() 374 375 script.ShowProgress(0.5, 0) 376 377 if OPTIONS.wipe_user_data: 378 script.FormatPartition("userdata") 379 380 script.FormatPartition("system") 381 script.Mount("MTD", "system", "/system") 382 script.UnpackPackageDir("recovery", "/system") 383 script.UnpackPackageDir("system", "/system") 384 385 symlinks = CopySystemFiles(input_zip, output_zip) 386 script.MakeSymlinks(symlinks) 387 388 boot_img = File("boot.img", common.BuildBootableImage( 389 os.path.join(OPTIONS.input_tmp, "BOOT"))) 390 recovery_img = File("recovery.img", common.BuildBootableImage( 391 os.path.join(OPTIONS.input_tmp, "RECOVERY"))) 392 MakeRecoveryPatch(output_zip, recovery_img, boot_img) 393 394 Item.GetMetadata(input_zip) 395 Item.Get("system").SetPermissions(script) 396 397 common.CheckSize(boot_img.data, "boot.img") 398 common.ZipWriteStr(output_zip, "boot.img", boot_img.data) 399 script.ShowProgress(0.2, 0) 400 401 script.ShowProgress(0.2, 10) 402 script.WriteRawImage("boot", "boot.img") 403 404 script.ShowProgress(0.1, 0) 405 device_specific.FullOTA_InstallEnd() 406 407 if OPTIONS.extra_script is not None: 408 script.AppendExtra(OPTIONS.extra_script) 409 410 script.UnmountAll() 411 script.AddToZip(input_zip, output_zip) 412 WriteMetadata(metadata, output_zip) 413 414 415 def WriteMetadata(metadata, output_zip): 416 common.ZipWriteStr(output_zip, "META-INF/com/android/metadata", 417 "".join(["%s=%s\n" % kv 418 for kv in sorted(metadata.iteritems())])) 419 420 421 class File(object): 422 def __init__(self, name, data): 423 self.name = name 424 self.data = data 425 self.size = len(data) 426 self.sha1 = sha.sha(data).hexdigest() 427 428 def WriteToTemp(self): 429 t = tempfile.NamedTemporaryFile() 430 t.write(self.data) 431 t.flush() 432 return t 433 434 def AddToZip(self, z): 435 common.ZipWriteStr(z, self.name, self.data) 436 437 438 def LoadSystemFiles(z): 439 """Load all the files from SYSTEM/... in a given target-files 440 ZipFile, and return a dict of {filename: File object}.""" 441 out = {} 442 for info in z.infolist(): 443 if info.filename.startswith("SYSTEM/") and not IsSymlink(info): 444 fn = "system/" + info.filename[7:] 445 data = z.read(info.filename) 446 out[fn] = File(fn, data) 447 return out 448 449 450 DIFF_PROGRAM_BY_EXT = { 451 ".gz" : "imgdiff", 452 ".zip" : ["imgdiff", "-z"], 453 ".jar" : ["imgdiff", "-z"], 454 ".apk" : ["imgdiff", "-z"], 455 ".img" : "imgdiff", 456 } 457 458 459 class Difference(object): 460 def __init__(self, tf, sf): 461 self.tf = tf 462 self.sf = sf 463 self.patch = None 464 465 def ComputePatch(self): 466 """Compute the patch (as a string of data) needed to turn sf into 467 tf. Returns the same tuple as GetPatch().""" 468 469 tf = self.tf 470 sf = self.sf 471 472 ext = os.path.splitext(tf.name)[1] 473 diff_program = DIFF_PROGRAM_BY_EXT.get(ext, "bsdiff") 474 475 ttemp = tf.WriteToTemp() 476 stemp = sf.WriteToTemp() 477 478 ext = os.path.splitext(tf.name)[1] 479 480 try: 481 ptemp = tempfile.NamedTemporaryFile() 482 if isinstance(diff_program, list): 483 cmd = copy.copy(diff_program) 484 else: 485 cmd = [diff_program] 486 cmd.append(stemp.name) 487 cmd.append(ttemp.name) 488 cmd.append(ptemp.name) 489 p = common.Run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 490 _, err = p.communicate() 491 if err or p.returncode != 0: 492 print "WARNING: failure running %s:\n%s\n" % (diff_program, err) 493 return None 494 diff = ptemp.read() 495 finally: 496 ptemp.close() 497 stemp.close() 498 ttemp.close() 499 500 self.patch = diff 501 return self.tf, self.sf, self.patch 502 503 504 def GetPatch(self): 505 """Return a tuple (target_file, source_file, patch_data). 506 patch_data may be None if ComputePatch hasn't been called, or if 507 computing the patch failed.""" 508 return self.tf, self.sf, self.patch 509 510 511 def ComputeDifferences(diffs): 512 """Call ComputePatch on all the Difference objects in 'diffs'.""" 513 print len(diffs), "diffs to compute" 514 515 # Do the largest files first, to try and reduce the long-pole effect. 516 by_size = [(i.tf.size, i) for i in diffs] 517 by_size.sort(reverse=True) 518 by_size = [i[1] for i in by_size] 519 520 lock = threading.Lock() 521 diff_iter = iter(by_size) # accessed under lock 522 523 def worker(): 524 try: 525 lock.acquire() 526 for d in diff_iter: 527 lock.release() 528 start = time.time() 529 d.ComputePatch() 530 dur = time.time() - start 531 lock.acquire() 532 533 tf, sf, patch = d.GetPatch() 534 if sf.name == tf.name: 535 name = tf.name 536 else: 537 name = "%s (%s)" % (tf.name, sf.name) 538 if patch is None: 539 print "patching failed! %s" % (name,) 540 else: 541 print "%8.2f sec %8d / %8d bytes (%6.2f%%) %s" % ( 542 dur, len(patch), tf.size, 100.0 * len(patch) / tf.size, name) 543 lock.release() 544 except Exception, e: 545 print e 546 raise 547 548 # start worker threads; wait for them all to finish. 549 threads = [threading.Thread(target=worker) 550 for i in range(OPTIONS.worker_threads)] 551 for th in threads: 552 th.start() 553 while threads: 554 threads.pop().join() 555 556 557 def GetBuildProp(property, z): 558 """Return the fingerprint of the build of a given target-files 559 ZipFile object.""" 560 bp = z.read("SYSTEM/build.prop") 561 if not property: 562 return bp 563 m = re.search(re.escape(property) + r"=(.*)\n", bp) 564 if not m: 565 raise common.ExternalError("couldn't find %s in build.prop" % (property,)) 566 return m.group(1).strip() 567 568 569 def GetRecoveryAPIVersion(zip): 570 """Returns the version of the recovery API. Version 0 is the older 571 amend code (no separate binary).""" 572 try: 573 version = zip.read("META/recovery-api-version.txt") 574 return int(version) 575 except KeyError: 576 try: 577 # version one didn't have the recovery-api-version.txt file, but 578 # it did include an updater binary. 579 zip.getinfo("OTA/bin/updater") 580 return 1 581 except KeyError: 582 return 0 583 584 585 def WriteIncrementalOTAPackage(target_zip, source_zip, output_zip): 586 source_version = GetRecoveryAPIVersion(source_zip) 587 target_version = GetRecoveryAPIVersion(target_zip) 588 589 if OPTIONS.script_mode == 'amend': 590 script = amend_generator.AmendGenerator() 591 elif OPTIONS.script_mode == 'edify': 592 if source_version == 0: 593 print ("WARNING: generating edify script for a source that " 594 "can't install it.") 595 script = edify_generator.EdifyGenerator(source_version) 596 elif OPTIONS.script_mode == 'auto': 597 if source_version > 0: 598 script = edify_generator.EdifyGenerator(source_version) 599 else: 600 script = amend_generator.AmendGenerator() 601 else: 602 raise ValueError('unknown script mode "%s"' % (OPTIONS.script_mode,)) 603 604 metadata = {"pre-device": GetBuildProp("ro.product.device", source_zip), 605 } 606 607 device_specific = common.DeviceSpecificParams( 608 source_zip=source_zip, 609 source_version=source_version, 610 target_zip=target_zip, 611 target_version=target_version, 612 output_zip=output_zip, 613 script=script, 614 metadata=metadata) 615 616 print "Loading target..." 617 target_data = LoadSystemFiles(target_zip) 618 print "Loading source..." 619 source_data = LoadSystemFiles(source_zip) 620 621 verbatim_targets = [] 622 patch_list = [] 623 diffs = [] 624 largest_source_size = 0 625 for fn in sorted(target_data.keys()): 626 tf = target_data[fn] 627 assert fn == tf.name 628 sf = source_data.get(fn, None) 629 630 if sf is None or fn in OPTIONS.require_verbatim: 631 # This file should be included verbatim 632 if fn in OPTIONS.prohibit_verbatim: 633 raise common.ExternalError("\"%s\" must be sent verbatim" % (fn,)) 634 print "send", fn, "verbatim" 635 tf.AddToZip(output_zip) 636 verbatim_targets.append((fn, tf.size)) 637 elif tf.sha1 != sf.sha1: 638 # File is different; consider sending as a patch 639 diffs.append(Difference(tf, sf)) 640 else: 641 # Target file identical to source. 642 pass 643 644 ComputeDifferences(diffs) 645 646 for diff in diffs: 647 tf, sf, d = diff.GetPatch() 648 if d is None or len(d) > tf.size * OPTIONS.patch_threshold: 649 # patch is almost as big as the file; don't bother patching 650 tf.AddToZip(output_zip) 651 verbatim_targets.append((tf.name, tf.size)) 652 else: 653 common.ZipWriteStr(output_zip, "patch/" + tf.name + ".p", d) 654 patch_list.append((tf.name, tf, sf, tf.size, sha.sha(d).hexdigest())) 655 largest_source_size = max(largest_source_size, sf.size) 656 657 source_fp = GetBuildProp("ro.build.fingerprint", source_zip) 658 target_fp = GetBuildProp("ro.build.fingerprint", target_zip) 659 metadata["pre-build"] = source_fp 660 metadata["post-build"] = target_fp 661 662 script.Mount("MTD", "system", "/system") 663 script.AssertSomeFingerprint(source_fp, target_fp) 664 665 source_boot = File("/tmp/boot.img", 666 common.BuildBootableImage( 667 os.path.join(OPTIONS.source_tmp, "BOOT"))) 668 target_boot = File("/tmp/boot.img", 669 common.BuildBootableImage( 670 os.path.join(OPTIONS.target_tmp, "BOOT"))) 671 updating_boot = (source_boot.data != target_boot.data) 672 673 source_recovery = File("system/recovery.img", 674 common.BuildBootableImage( 675 os.path.join(OPTIONS.source_tmp, "RECOVERY"))) 676 target_recovery = File("system/recovery.img", 677 common.BuildBootableImage( 678 os.path.join(OPTIONS.target_tmp, "RECOVERY"))) 679 updating_recovery = (source_recovery.data != target_recovery.data) 680 681 # Here's how we divide up the progress bar: 682 # 0.1 for verifying the start state (PatchCheck calls) 683 # 0.8 for applying patches (ApplyPatch calls) 684 # 0.1 for unpacking verbatim files, symlinking, and doing the 685 # device-specific commands. 686 687 AppendAssertions(script, target_zip) 688 device_specific.IncrementalOTA_Assertions() 689 690 script.Print("Verifying current system...") 691 692 script.ShowProgress(0.1, 0) 693 total_verify_size = float(sum([i[2].size for i in patch_list]) + 1) 694 if updating_boot: 695 total_verify_size += source_boot.size 696 so_far = 0 697 698 for fn, tf, sf, size, patch_sha in patch_list: 699 script.PatchCheck("/"+fn, tf.sha1, sf.sha1) 700 so_far += sf.size 701 script.SetProgress(so_far / total_verify_size) 702 703 if updating_boot: 704 d = Difference(target_boot, source_boot) 705 _, _, d = d.ComputePatch() 706 print "boot target: %d source: %d diff: %d" % ( 707 target_boot.size, source_boot.size, len(d)) 708 709 common.ZipWriteStr(output_zip, "patch/boot.img.p", d) 710 711 script.PatchCheck("MTD:boot:%d:%s:%d:%s" % 712 (source_boot.size, source_boot.sha1, 713 target_boot.size, target_boot.sha1)) 714 so_far += source_boot.size 715 script.SetProgress(so_far / total_verify_size) 716 717 if patch_list or updating_recovery or updating_boot: 718 script.CacheFreeSpaceCheck(largest_source_size) 719 720 device_specific.IncrementalOTA_VerifyEnd() 721 722 script.Comment("---- start making changes here ----") 723 724 if OPTIONS.wipe_user_data: 725 script.Print("Erasing user data...") 726 script.FormatPartition("userdata") 727 728 script.Print("Removing unneeded files...") 729 script.DeleteFiles(["/"+i[0] for i in verbatim_targets] + 730 ["/"+i for i in sorted(source_data) 731 if i not in target_data] + 732 ["/system/recovery.img"]) 733 734 script.ShowProgress(0.8, 0) 735 total_patch_size = float(sum([i[1].size for i in patch_list]) + 1) 736 if updating_boot: 737 total_patch_size += target_boot.size 738 so_far = 0 739 740 script.Print("Patching system files...") 741 for fn, tf, sf, size, _ in patch_list: 742 script.ApplyPatch("/"+fn, "-", tf.size, tf.sha1, sf.sha1, "patch/"+fn+".p") 743 so_far += tf.size 744 script.SetProgress(so_far / total_patch_size) 745 746 if updating_boot: 747 # Produce the boot image by applying a patch to the current 748 # contents of the boot partition, and write it back to the 749 # partition. 750 script.Print("Patching boot image...") 751 script.ApplyPatch("MTD:boot:%d:%s:%d:%s" 752 % (source_boot.size, source_boot.sha1, 753 target_boot.size, target_boot.sha1), 754 "-", 755 target_boot.size, target_boot.sha1, 756 source_boot.sha1, "patch/boot.img.p") 757 so_far += target_boot.size 758 script.SetProgress(so_far / total_patch_size) 759 print "boot image changed; including." 760 else: 761 print "boot image unchanged; skipping." 762 763 if updating_recovery: 764 # Is it better to generate recovery as a patch from the current 765 # boot image, or from the previous recovery image? For large 766 # updates with significant kernel changes, probably the former. 767 # For small updates where the kernel hasn't changed, almost 768 # certainly the latter. We pick the first option. Future 769 # complicated schemes may let us effectively use both. 770 # 771 # A wacky possibility: as long as there is room in the boot 772 # partition, include the binaries and image files from recovery in 773 # the boot image (though not in the ramdisk) so they can be used 774 # as fodder for constructing the recovery image. 775 MakeRecoveryPatch(output_zip, target_recovery, target_boot) 776 script.DeleteFiles(["/system/recovery-from-boot.p", 777 "/system/etc/install-recovery.sh"]) 778 print "recovery image changed; including as patch from boot." 779 else: 780 print "recovery image unchanged; skipping." 781 782 script.ShowProgress(0.1, 10) 783 784 target_symlinks = CopySystemFiles(target_zip, None) 785 786 target_symlinks_d = dict([(i[1], i[0]) for i in target_symlinks]) 787 temp_script = script.MakeTemporary() 788 Item.GetMetadata(target_zip) 789 Item.Get("system").SetPermissions(temp_script) 790 791 # Note that this call will mess up the tree of Items, so make sure 792 # we're done with it. 793 source_symlinks = CopySystemFiles(source_zip, None) 794 source_symlinks_d = dict([(i[1], i[0]) for i in source_symlinks]) 795 796 # Delete all the symlinks in source that aren't in target. This 797 # needs to happen before verbatim files are unpacked, in case a 798 # symlink in the source is replaced by a real file in the target. 799 to_delete = [] 800 for dest, link in source_symlinks: 801 if link not in target_symlinks_d: 802 to_delete.append(link) 803 script.DeleteFiles(to_delete) 804 805 if verbatim_targets: 806 script.Print("Unpacking new files...") 807 script.UnpackPackageDir("system", "/system") 808 809 if updating_recovery: 810 script.Print("Unpacking new recovery...") 811 script.UnpackPackageDir("recovery", "/system") 812 813 script.Print("Symlinks and permissions...") 814 815 # Create all the symlinks that don't already exist, or point to 816 # somewhere different than what we want. Delete each symlink before 817 # creating it, since the 'symlink' command won't overwrite. 818 to_create = [] 819 for dest, link in target_symlinks: 820 if link in source_symlinks_d: 821 if dest != source_symlinks_d[link]: 822 to_create.append((dest, link)) 823 else: 824 to_create.append((dest, link)) 825 script.DeleteFiles([i[1] for i in to_create]) 826 script.MakeSymlinks(to_create) 827 828 # Now that the symlinks are created, we can set all the 829 # permissions. 830 script.AppendScript(temp_script) 831 832 # Do device-specific installation (eg, write radio image). 833 device_specific.IncrementalOTA_InstallEnd() 834 835 if OPTIONS.extra_script is not None: 836 scirpt.AppendExtra(OPTIONS.extra_script) 837 838 script.AddToZip(target_zip, output_zip) 839 WriteMetadata(metadata, output_zip) 840 841 842 def main(argv): 843 844 def option_handler(o, a): 845 if o in ("-b", "--board_config"): 846 pass # deprecated 847 elif o in ("-k", "--package_key"): 848 OPTIONS.package_key = a 849 elif o in ("-i", "--incremental_from"): 850 OPTIONS.incremental_source = a 851 elif o in ("-w", "--wipe_user_data"): 852 OPTIONS.wipe_user_data = True 853 elif o in ("-n", "--no_prereq"): 854 OPTIONS.omit_prereq = True 855 elif o in ("-e", "--extra_script"): 856 OPTIONS.extra_script = a 857 elif o in ("-m", "--script_mode"): 858 OPTIONS.script_mode = a 859 elif o in ("--worker_threads"): 860 OPTIONS.worker_threads = int(a) 861 else: 862 return False 863 return True 864 865 args = common.ParseOptions(argv, __doc__, 866 extra_opts="b:k:i:d:wne:m:", 867 extra_long_opts=["board_config=", 868 "package_key=", 869 "incremental_from=", 870 "wipe_user_data", 871 "no_prereq", 872 "extra_script=", 873 "script_mode=", 874 "worker_threads="], 875 extra_option_handler=option_handler) 876 877 if len(args) != 2: 878 common.Usage(__doc__) 879 sys.exit(1) 880 881 if OPTIONS.script_mode not in ("amend", "edify", "auto"): 882 raise ValueError('unknown script mode "%s"' % (OPTIONS.script_mode,)) 883 884 if OPTIONS.extra_script is not None: 885 OPTIONS.extra_script = open(OPTIONS.extra_script).read() 886 887 print "unzipping target target-files..." 888 OPTIONS.input_tmp = common.UnzipTemp(args[0]) 889 890 if OPTIONS.device_specific is None: 891 # look for the device-specific tools extension location in the input 892 try: 893 f = open(os.path.join(OPTIONS.input_tmp, "META", "tool-extensions.txt")) 894 ds = f.read().strip() 895 f.close() 896 if ds: 897 ds = os.path.normpath(ds) 898 print "using device-specific extensions in", ds 899 OPTIONS.device_specific = ds 900 except IOError, e: 901 if e.errno == errno.ENOENT: 902 # nothing specified in the file 903 pass 904 else: 905 raise 906 907 common.LoadMaxSizes() 908 if not OPTIONS.max_image_size: 909 print 910 print " WARNING: Failed to load max image sizes; will not enforce" 911 print " image size limits." 912 print 913 914 OPTIONS.target_tmp = OPTIONS.input_tmp 915 input_zip = zipfile.ZipFile(args[0], "r") 916 if OPTIONS.package_key: 917 temp_zip_file = tempfile.NamedTemporaryFile() 918 output_zip = zipfile.ZipFile(temp_zip_file, "w", 919 compression=zipfile.ZIP_DEFLATED) 920 else: 921 output_zip = zipfile.ZipFile(args[1], "w", 922 compression=zipfile.ZIP_DEFLATED) 923 924 if OPTIONS.incremental_source is None: 925 WriteFullOTAPackage(input_zip, output_zip) 926 else: 927 print "unzipping source target-files..." 928 OPTIONS.source_tmp = common.UnzipTemp(OPTIONS.incremental_source) 929 source_zip = zipfile.ZipFile(OPTIONS.incremental_source, "r") 930 WriteIncrementalOTAPackage(input_zip, source_zip, output_zip) 931 932 output_zip.close() 933 if OPTIONS.package_key: 934 SignOutput(temp_zip_file.name, args[1]) 935 temp_zip_file.close() 936 937 common.Cleanup() 938 939 print "done." 940 941 942 if __name__ == '__main__': 943 try: 944 main(sys.argv[1:]) 945 except common.ExternalError, e: 946 print 947 print " ERROR: %s" % (e,) 948 print 949 sys.exit(1) 950
