tools/releasetools/ota_from_target_files

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