安卓升级固件update.zip解析

一、update.zip包目录结构详解
     1、boot.img是更新boot分区所需要的文件。这个boot.img主要包括kernel+ramdisk。
     2、system/目录的内容在升级后会放在系统的system分区。主要用来更新系统的一些应用或则应用会用到的一些库等等。可以将Android源码编译out/target/product/tcc8800/system/中的所有文件拷贝到这个目录来代替。
     3、recovery/目录中的recovery-from-boot.p是boot.img和recovery.img的补丁(patch),主要用来更新recovery分区,其中etc/目录下的install-recovery.sh是更新脚本。
     4、update-binary是一个二进制文件,相当于一个脚本解释器,能够识别updater-script中描述的操作。该文件在Android源码编译后out/target/product/tcc8800/system bin/updater生成,可将updater重命名为update-binary得到。该文件在具体的更新包中的名字由源码中bootable/recovery/install.c中的宏ASSUMED_UPDATE_BINARY_NAME的值而定。
     5、updater-script:此文件是一个脚本文件,具体描述了更新过程。我们可以根据具体情况编写该脚本来适应我们的具体需求。该文件的命名由源码中bootable/recovery/updater/updater.c文件中的宏SCRIPT_NAME的值而定。
     6、metadata文件是描述设备信息及环境变量的元数据。主要包括一些编译选项,签名公钥,时间戳以及设备型号等。
     7、我们还可以在包中添加userdata目录,来更新系统中的用户数据部分。这部分内容在更新后会存放在系统的/data目录下。
     8、update.zip包的签名:update.zip更新包在制作完成后需要对其签名,否则在升级时会出现认证失败的错误提示。而且签名要使用和目标板一致的加密公钥。加密公钥及加密需要的三个文件在Android源码编译后生成的具体路径为:
         out/host/Linux-x86/framework/signapk.jar 
         build/target/product/security/testkey.x509.pem         
         build/target/product/security/testkey.pk8 。
         我们用命令make otapackage制作生成的update.zip包是已签过名的,如果自己做update.zip包时必须手动对其签名。
         具体的加密方法:$ java –jar gingerbread/out/host/linux/framework/signapk.jar –w gingerbread/build/target/product/security/testkey.x509.pem                                      gingerbread/build/target/product/security/testkey.pk8 update.zip update_signed.zip
         以上命令在update.zip包所在的路径下执行,其中signapk.jar testkey.x509.pem以及testkey.pk8文件的引用使用绝对路径。update.zip 是我们已经打好的包,update_signed.zip包是命令执行完生成的已经签过名的包。
     9、MANIFEST.MF:这个manifest文件定义了与包的组成结构相关的数据。类似Android应用的mainfest.xml文件。

    10、CERT.RSA:与签名文件相关联的签名程序块文件,它存储了用于签名JAR文件的公共签名

    11、CERT.SF:这是JAR文件的签名文件,其中前缀CERT代表签名者。


二、Android升级包update.zip的生成过程分析

        1.命令制作。Android源码系统中为我们提供了制作update.zip刷机包的命令,即make otapackage。该命令在编译源码完成后并在源码根目录下执行。 具体操作方式:在源码根目录下执行
                ①$ source build/envsetup.sh。 
                ②$ lunch 然后选择你需要的配置(如17)。
                ③$ make otapackage。
        2.使用make otapackage命令生成update.zip的过程分析。
            在源码根目录下执行make otapackage命令生成update.zip包主要分为两步,第一步是根据Makefile执行编译生成一个update原包(zip格式)。第二步是运行一个python脚本,并以上一步准备的zip包作为输入,最终生成我们需要的升级包。下面进一步分析这两个过程。
[python] view plain copy
print ?
  1. <span style="font-size:14px;"># A zip of the directories that map to the target filesystem.  
  2. # This zip can be used to create an OTA package or filesystem image  
  3. # as a post-build step.  
  4. #  
  5. name := $(TARGET_PRODUCT)  
  6. ifeq ($(TARGET_BUILD_TYPE),debug)  
  7.   name := $(name)_debug  
  8. endif  
  9. name := $(name)-target_files-$(FILE_NAME_TAG)  
  10.   
  11.   
  12. intermediates := $(call intermediates-dir-for,PACKAGING,target_files)  
  13. BUILT_TARGET_FILES_PACKAGE := $(intermediates)/$(name).zip  
  14. $(BUILT_TARGET_FILES_PACKAGE): intermediates := $(intermediates)  
  15. $(BUILT_TARGET_FILES_PACKAGE): \  
  16. zip_root := $(intermediates)/$(name)  
  17.   
  18.   
  19. # $(1): Directory to copy  
  20. # $(2): Location to copy it to  
  21. # The "ls -A" is to prevent "acp s/* d" from failing if s is empty.  
  22. define package_files-copy-root  
  23.   if [ -d "$(strip $(1))" -a "$$(ls -A $(1))" ]; then \  
  24.     mkdir -p $(2) && \  
  25.     $(ACP) -rd $(strip $(1))/* $(2); \  
  26.   fi  
  27. endef  
  28.   
  29.   
  30. built_ota_tools := \  
  31. $(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \  
  32. $(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \  
  33. $(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \  
  34. $(call intermediates-dir-for,EXECUTABLES,sqlite3)/sqlite3 \  
  35. $(call intermediates-dir-for,EXECUTABLES,updater)/updater  
  36. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)  
  37.   
  38.   
  39. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_VERSION)  
  40. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_FSTAB_VERSION := $(RECOVERY_FSTAB_VERSION)  
  41.   
  42.   
  43. ifeq ($(TARGET_RELEASETOOLS_EXTENSIONS),)  
  44. # default to common dir for device vendor  
  45. $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_DEVICE_DIR)/../common  
  46. else  
  47. $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_RELEASETOOLS_EXTENSIONS)  
  48. endif  
  49.   
  50.   
  51. # Depending on the various images guarantees that the underlying  
  52. # directories are up-to-date.  
  53. $(BUILT_TARGET_FILES_PACKAGE): \  
  54. $(INSTALLED_BOOTIMAGE_TARGET) \  
  55. $(INSTALLED_RADIOIMAGE_TARGET) \  
  56. $(INSTALLED_RECOVERYIMAGE_TARGET) \  
  57. $(INSTALLED_SYSTEMIMAGE) \  
  58. $(INSTALLED_USERDATAIMAGE_TARGET) \  
  59. $(INSTALLED_CACHEIMAGE_TARGET) \  
  60. $(INSTALLED_VENDORIMAGE_TARGET) \  
  61. $(INSTALLED_ANDROID_INFO_TXT_TARGET) \  
  62. $(SELINUX_FC) \  
  63. $(built_ota_tools) \  
  64. $(APKCERTS_FILE) \  
  65. $(HOST_OUT_EXECUTABLES)/fs_config \  
  66. | $(ACP)  
  67. @echo "Package target files: $@"  
  68. $(hide) rm -rf $@ $(zip_root)  
  69. $(hide) mkdir -p $(dir $@) $(zip_root)  
  70. @# Components of the recovery image  
  71. $(hide) mkdir -p $(zip_root)/RECOVERY  
  72. $(hide) $(call package_files-copy-root, \  
  73. $(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)  
  74. ifdef INSTALLED_KERNEL_TARGET  
  75. $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/RECOVERY/kernel  
  76. endif  
  77. ifdef INSTALLED_2NDBOOTLOADER_TARGET  
  78. $(hide) $(ACP) \  
  79. $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/RECOVERY/second  
  80. endif  
  81. ifdef BOARD_KERNEL_CMDLINE  
  82. $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/RECOVERY/cmdline  
  83. endif  
  84. ifdef BOARD_KERNEL_BASE  
  85. $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/RECOVERY/base  
  86. endif  
  87. ifdef BOARD_KERNEL_PAGESIZE  
  88. $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/RECOVERY/pagesize  
  89. endif  
  90. @# Components of the boot image  
  91. $(hide) mkdir -p $(zip_root)/BOOT  
  92. $(hide) $(call package_files-copy-root, \  
  93. $(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)  
  94. ifdef INSTALLED_KERNEL_TARGET  
  95. $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/BOOT/kernel  
  96. endif  
  97. ifdef INSTALLED_2NDBOOTLOADER_TARGET  
  98. $(hide) $(ACP) \  
  99. $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/BOOT/second  
  100. endif  
  101. ifdef BOARD_KERNEL_CMDLINE  
  102. $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/BOOT/cmdline  
  103. endif  
  104. ifdef BOARD_KERNEL_BASE  
  105. $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/BOOT/base  
  106. endif  
  107. ifdef BOARD_KERNEL_PAGESIZE  
  108. $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/BOOT/pagesize  
  109. endif  
  110. $(hide) $(foreach t,$(INSTALLED_RADIOIMAGE_TARGET),\  
  111.             mkdir -p $(zip_root)/RADIO; \  
  112.             $(ACP) $(t) $(zip_root)/RADIO/$(notdir $(t));)  
  113. @# Contents of the system image  
  114. $(hide) $(call package_files-copy-root, \  
  115. $(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)  
  116. @# Contents of the data image  
  117. $(hide) $(call package_files-copy-root, \  
  118. $(TARGET_OUT_DATA),$(zip_root)/DATA)  
  119. ifdef BOARD_VENDORIMAGE_FILE_SYSTEM_TYPE  
  120. @# Contents of the vendor image  
  121. $(hide) $(call package_files-copy-root, \  
  122. $(TARGET_OUT_VENDOR),$(zip_root)/VENDOR)  
  123. endif  
  124. @# Extra contents of the OTA package  
  125. $(hide) mkdir -p $(zip_root)/OTA/bin  
  126. $(hide) $(ACP) $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/  
  127. $(hide) $(ACP) $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/  
  128. @# Files that do not end up in any images, but are necessary to  
  129. @# build them.  
  130. $(hide) mkdir -p $(zip_root)/META  
  131. $(hide) $(ACP) $(APKCERTS_FILE) $(zip_root)/META/apkcerts.txt  
  132. $(hide)echo "$(PRODUCT_OTA_PUBLIC_KEYS)" > $(zip_root)/META/otakeys.txt  
  133. $(hide) echo "recovery_api_version=$(PRIVATE_RECOVERY_API_VERSION)" > $(zip_root)/META/misc_info.txt  
  134. $(hide) echo "fstab_version=$(PRIVATE_RECOVERY_FSTAB_VERSION)" >> $(zip_root)/META/misc_info.txt  
  135. ifdef BOARD_FLASH_BLOCK_SIZE  
  136. $(hide) echo "blocksize=$(BOARD_FLASH_BLOCK_SIZE)" >> $(zip_root)/META/misc_info.txt  
  137. endif  
  138. ifdef BOARD_BOOTIMAGE_PARTITION_SIZE  
  139. $(hide) echo "boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt  
  140. endif  
  141. ifdef BOARD_RECOVERYIMAGE_PARTITION_SIZE  
  142. $(hide) echo "recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt  
  143. endif  
  144. $(hide) echo "tool_extensions=$(tool_extensions)" >> $(zip_root)/META/misc_info.txt  
  145. $(hide) echo "default_system_dev_certificate=$(DEFAULT_SYSTEM_DEV_CERTIFICATE)" >> $(zip_root)/META/misc_info.txt  
  146. ifdef PRODUCT_EXTRA_RECOVERY_KEYS  
  147. $(hide) echo "extra_recovery_keys=$(PRODUCT_EXTRA_RECOVERY_KEYS)" >> $(zip_root)/META/misc_info.txt  
  148. endif  
  149. $(hide) echo "mkbootimg_args=$(BOARD_MKBOOTIMG_ARGS)" >> $(zip_root)/META/misc_info.txt  
  150. $(hide) echo "use_set_metadata=1" >> $(zip_root)/META/misc_info.txt  
  151. $(hide) echo "update_rename_support=1" >> $(zip_root)/META/misc_info.txt  
  152. $(call generate-userimage-prop-dictionary, $(zip_root)/META/misc_info.txt)  
  153. @# Zip everything up, preserving symlinks  
  154. $(hide) (cd $(zip_root) && zip -qry ../$(notdir $@) .)  
  155. @# Run fs_config on all the system, boot ramdisk, and recovery ramdisk files in the zip, and save the output  
  156. $(hide) zipinfo -1 $@ | awk 'BEGIN { FS="SYSTEM/" } /^SYSTEM\// {print "system/" $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) > $(zip_root)/META/filesystem_config.txt  
  157. $(hide) zipinfo -1 $@ | awk 'BEGIN { FS="BOOT/RAMDISK/" } /^BOOT\/RAMDISK\// {print $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) > $(zip_root)/META/boot_filesystem_config.txt  
  158. $(hide) zipinfo -1 $@ | awk 'BEGIN { FS="RECOVERY/RAMDISK/" } /^RECOVERY\/RAMDISK\// {print $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) > $(zip_root)/META/recovery_filesystem_config.txt  
  159. $(hide) (cd $(zip_root) && zip -q ../$(notdir $@) META/*filesystem_config.txt)  
  160.   
  161. .PHONY: target-files-package  
  162. target-files-package: $(BUILT_TARGET_FILES_PACKAGE)  
  163.   
  164. ifneq ($(TARGET_PRODUCT),sdk)  
  165. ifeq ($(filter generic%,$(TARGET_DEVICE)),)  
  166. ifneq ($(TARGET_NO_KERNEL),true)  
  167. ifneq ($(recovery_fstab),)<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">     </span></span>  
<span style="font-size:14px;"># A zip of the directories that map to the target filesystem.
# This zip can be used to create an OTA package or filesystem image
# as a post-build step.
#
name := $(TARGET_PRODUCT)
ifeq ($(TARGET_BUILD_TYPE),debug)
  name := $(name)_debug
endif
name := $(name)-target_files-$(FILE_NAME_TAG)


intermediates := $(call intermediates-dir-for,PACKAGING,target_files)
BUILT_TARGET_FILES_PACKAGE := $(intermediates)/$(name).zip
$(BUILT_TARGET_FILES_PACKAGE): intermediates := $(intermediates)
$(BUILT_TARGET_FILES_PACKAGE): \
zip_root := $(intermediates)/$(name)


# $(1): Directory to copy
# $(2): Location to copy it to
# The "ls -A" is to prevent "acp s/* d" from failing if s is empty.
define package_files-copy-root
  if [ -d "$(strip $(1))" -a "$$(ls -A $(1))" ]; then \
    mkdir -p $(2) && \
    $(ACP) -rd $(strip $(1))/* $(2); \
  fi
endef


built_ota_tools := \
$(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \
$(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \
$(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \
$(call intermediates-dir-for,EXECUTABLES,sqlite3)/sqlite3 \
$(call intermediates-dir-for,EXECUTABLES,updater)/updater
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)


$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_VERSION)
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_FSTAB_VERSION := $(RECOVERY_FSTAB_VERSION)


ifeq ($(TARGET_RELEASETOOLS_EXTENSIONS),)
# default to common dir for device vendor
$(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_DEVICE_DIR)/../common
else
$(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_RELEASETOOLS_EXTENSIONS)
endif


# Depending on the various images guarantees that the underlying
# directories are up-to-date.
$(BUILT_TARGET_FILES_PACKAGE): \
$(INSTALLED_BOOTIMAGE_TARGET) \
$(INSTALLED_RADIOIMAGE_TARGET) \
$(INSTALLED_RECOVERYIMAGE_TARGET) \
$(INSTALLED_SYSTEMIMAGE) \
$(INSTALLED_USERDATAIMAGE_TARGET) \
$(INSTALLED_CACHEIMAGE_TARGET) \
$(INSTALLED_VENDORIMAGE_TARGET) \
$(INSTALLED_ANDROID_INFO_TXT_TARGET) \
$(SELINUX_FC) \
$(built_ota_tools) \
$(APKCERTS_FILE) \
$(HOST_OUT_EXECUTABLES)/fs_config \
| $(ACP)
@echo "Package target files: $@"
$(hide) rm -rf $@ $(zip_root)
$(hide) mkdir -p $(dir $@) $(zip_root)
@# Components of the recovery image
$(hide) mkdir -p $(zip_root)/RECOVERY
$(hide) $(call package_files-copy-root, \
$(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)
ifdef INSTALLED_KERNEL_TARGET
$(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/RECOVERY/kernel
endif
ifdef INSTALLED_2NDBOOTLOADER_TARGET
$(hide) $(ACP) \
$(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/RECOVERY/second
endif
ifdef BOARD_KERNEL_CMDLINE
$(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/RECOVERY/cmdline
endif
ifdef BOARD_KERNEL_BASE
$(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/RECOVERY/base
endif
ifdef BOARD_KERNEL_PAGESIZE
$(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/RECOVERY/pagesize
endif
@# Components of the boot image
$(hide) mkdir -p $(zip_root)/BOOT
$(hide) $(call package_files-copy-root, \
$(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)
ifdef INSTALLED_KERNEL_TARGET
$(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/BOOT/kernel
endif
ifdef INSTALLED_2NDBOOTLOADER_TARGET
$(hide) $(ACP) \
$(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/BOOT/second
endif
ifdef BOARD_KERNEL_CMDLINE
$(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/BOOT/cmdline
endif
ifdef BOARD_KERNEL_BASE
$(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/BOOT/base
endif
ifdef BOARD_KERNEL_PAGESIZE
$(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/BOOT/pagesize
endif
$(hide) $(foreach t,$(INSTALLED_RADIOIMAGE_TARGET),\
            mkdir -p $(zip_root)/RADIO; \
            $(ACP) $(t) $(zip_root)/RADIO/$(notdir $(t));)
@# Contents of the system image
$(hide) $(call package_files-copy-root, \
$(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)
@# Contents of the data image
$(hide) $(call package_files-copy-root, \
$(TARGET_OUT_DATA),$(zip_root)/DATA)
ifdef BOARD_VENDORIMAGE_FILE_SYSTEM_TYPE
@# Contents of the vendor image
$(hide) $(call package_files-copy-root, \
$(TARGET_OUT_VENDOR),$(zip_root)/VENDOR)
endif
@# Extra contents of the OTA package
$(hide) mkdir -p $(zip_root)/OTA/bin
$(hide) $(ACP) $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/
$(hide) $(ACP) $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/
@# Files that do not end up in any images, but are necessary to
@# build them.
$(hide) mkdir -p $(zip_root)/META
$(hide) $(ACP) $(APKCERTS_FILE) $(zip_root)/META/apkcerts.txt
$(hide)echo "$(PRODUCT_OTA_PUBLIC_KEYS)" > $(zip_root)/META/otakeys.txt
$(hide) echo "recovery_api_version=$(PRIVATE_RECOVERY_API_VERSION)" > $(zip_root)/META/misc_info.txt
$(hide) echo "fstab_version=$(PRIVATE_RECOVERY_FSTAB_VERSION)" >> $(zip_root)/META/misc_info.txt
ifdef BOARD_FLASH_BLOCK_SIZE
$(hide) echo "blocksize=$(BOARD_FLASH_BLOCK_SIZE)" >> $(zip_root)/META/misc_info.txt
endif
ifdef BOARD_BOOTIMAGE_PARTITION_SIZE
$(hide) echo "boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt
endif
ifdef BOARD_RECOVERYIMAGE_PARTITION_SIZE
$(hide) echo "recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt
endif
$(hide) echo "tool_extensions=$(tool_extensions)" >> $(zip_root)/META/misc_info.txt
$(hide) echo "default_system_dev_certificate=$(DEFAULT_SYSTEM_DEV_CERTIFICATE)" >> $(zip_root)/META/misc_info.txt
ifdef PRODUCT_EXTRA_RECOVERY_KEYS
$(hide) echo "extra_recovery_keys=$(PRODUCT_EXTRA_RECOVERY_KEYS)" >> $(zip_root)/META/misc_info.txt
endif
$(hide) echo "mkbootimg_args=$(BOARD_MKBOOTIMG_ARGS)" >> $(zip_root)/META/misc_info.txt
$(hide) echo "use_set_metadata=1" >> $(zip_root)/META/misc_info.txt
$(hide) echo "update_rename_support=1" >> $(zip_root)/META/misc_info.txt
$(call generate-userimage-prop-dictionary, $(zip_root)/META/misc_info.txt)
@# Zip everything up, preserving symlinks
$(hide) (cd $(zip_root) && zip -qry ../$(notdir $@) .)
@# Run fs_config on all the system, boot ramdisk, and recovery ramdisk files in the zip, and save the output
$(hide) zipinfo -1 $@ | awk 'BEGIN { FS="SYSTEM/" } /^SYSTEM\// {print "system/" $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) > $(zip_root)/META/filesystem_config.txt
$(hide) zipinfo -1 $@ | awk 'BEGIN { FS="BOOT/RAMDISK/" } /^BOOT\/RAMDISK\// {print $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) > $(zip_root)/META/boot_filesystem_config.txt
$(hide) zipinfo -1 $@ | awk 'BEGIN { FS="RECOVERY/RAMDISK/" } /^RECOVERY\/RAMDISK\// {print $$2}' | $(HOST_OUT_EXECUTABLES)/fs_config -C -S $(SELINUX_FC) > $(zip_root)/META/recovery_filesystem_config.txt
$(hide) (cd $(zip_root) && zip -q ../$(notdir $@) META/*filesystem_config.txt)

.PHONY: target-files-package
target-files-package: $(BUILT_TARGET_FILES_PACKAGE)

ifneq ($(TARGET_PRODUCT),sdk)
ifeq ($(filter generic%,$(TARGET_DEVICE)),)
ifneq ($(TARGET_NO_KERNEL),true)
ifneq ($(recovery_fstab),)<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">		</span></span>
根据上面的Makefile可以分析这个包的生成过程:
    首先创建一个root_zip根目录,并依次在此目录下创建所需要的如下其他目录
    1)创建RECOVERY目录,并填充该目录的内容,包括kernel的镜像和recovery根文件系统的镜像。此目录最终用于生成recovery.img。
    2)创建并填充BOOT目录。包含kernel和cmdline以及pagesize大小等,该目录最终用来生成boot.img。
    3)向SYSTEM目录填充system image。
    4)向DATA填充data image。
    5)用于生成OTA package包所需要的额外的内容。主要包括一些bin命令。
    6)创建META目录并向该目录下添加一些文本文件,如apkcerts.txt(描述apk文件用到的认证证书),misc_info.txt(描述Flash内存的块大小以及boot、recovery、system、userdata等分区的大小信息)。
    7)使用保留连接选项压缩我们在上面获得的root_zip目录。
    8)使用fs_config(build/tools/fs_config)配置上面的zip包内所有的系统文件(system/下各目录、文件)的权限属主等信息。fs_config包含了一个头文件#include“private/android_filesystem_config.h”。在这个头文件中以硬编码的方式设定了system目录下各文件的权限、属主。执行完配置后会将配置后的信息以文本方式输出 到META/filesystem_config.txt中。并再一次zip压缩成我们最终需要的原始包。
    然后上面的zip包只是一个编译过程中生成的原始包。这个原始zip包在实际的编译过程中有两个作用,一是用来生成OTA update升级包,二是用来生成系统镜像,在编译过程中若生成OTA update升级包时会调用(具体位置在Makefile的1037行到1058行)一个名为 ota_from_target_files 的Python脚本,位置在/build/tools/releasetools/ota_from_target_files。这个脚本的作用是以第一步生成的zip原始包作为输入,最终生成可用的OTA升级zip包。
    下面我们分析使用这个脚本生成最终OTA升级包的过程。
    首先看一下这个脚本开始部分的帮助文档。代码如下:   
[python] view plain copy
print ?
  1. <span style="font-size:14px;"># Copyright (C) 2008 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.   
  15.   
  16. """  
  17. Given a target-files zipfile, produces an OTA package that installs  
  18. that build.  An incremental OTA is produced if -i is given, otherwise  
  19. a full OTA is produced.  
  20.   
  21.   
  22. Usage:  ota_from_target_files [flags] input_target_files output_ota_package  
  23.   
  24.   
  25.   -b  (--board_config)  <file>  
  26.       Deprecated.  
  27.   
  28.   
  29.   -k (--package_key) <key> Key to use to sign the package (default is  
  30.       the value of default_system_dev_certificate from the input  
  31.       target-files's META/misc_info.txt, or  
  32.       "build/target/product/security/testkey" if that value is not  
  33.       specified).  
  34.   
  35.   
  36.       For incremental OTAs, the default value is based on the source  
  37.       target-file, not the target build.  
  38.   
  39.   
  40.   -i  (--incremental_from)  <file>  
  41.       Generate an incremental OTA using the given target-files zip as  
  42.       the starting build.  
  43.   
  44.   
  45.   -w  (--wipe_user_data)  
  46.       Generate an OTA package that will wipe the user data partition  
  47.       when installed.  
  48.   
  49.   
  50.   -n  (--no_prereq)  
  51.       Omit the timestamp prereq check normally included at the top of  
  52.       the build scripts (used for developer OTA packages which  
  53.       legitimately need to go back and forth).  
  54.   
  55.   
  56.   -e  (--extra_script)  <file>  
  57.       Insert the contents of file at the end of the update script.  
  58.   
  59.   
  60.   -a  (--aslr_mode)  <on|off>  
  61.       Specify whether to turn on ASLR for the package (on by default).  
  62.   
  63.   
  64.     </span>  
<span style="font-size:14px;"># Copyright (C) 2008 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


"""
Given a target-files zipfile, produces an OTA package that installs
that build.  An incremental OTA is produced if -i is given, otherwise
a full OTA is produced.


Usage:  ota_from_target_files [flags] input_target_files output_ota_package


  -b  (--board_config)  <file>
      Deprecated.


  -k (--package_key) <key> Key to use to sign the package (default is
      the value of default_system_dev_certificate from the input
      target-files's META/misc_info.txt, or
      "build/target/product/security/testkey" if that value is not
      specified).


      For incremental OTAs, the default value is based on the source
      target-file, not the target build.


  -i  (--incremental_from)  <file>
      Generate an incremental OTA using the given target-files zip as
      the starting build.


  -w  (--wipe_user_data)
      Generate an OTA package that will wipe the user data partition
      when installed.


  -n  (--no_prereq)
      Omit the timestamp prereq check normally included at the top of
      the build scripts (used for developer OTA packages which
      legitimately need to go back and forth).


  -e  (--extra_script)  <file>
      Insert the contents of file at the end of the update script.


  -a  (--aslr_mode)  <on|off>
      Specify whether to turn on ASLR for the package (on by default).


	</span>
下面简单翻译一下他们的使用方法以及选项的作用。
    Usage: ota_from_target_files [flags] input_target_files output_ota_package
    -b 过时的。
    -k签名所使用的密钥
    -i生成增量OTA包时使用此选项。后面我们会用到这个选项来生成OTA增量包。
    -w是否清除userdata分区
    -n在升级时是否不检查时间戳,缺省要检查,即缺省情况下只能基于旧版本升级。
    -e是否有额外运行的脚本
    -m执行过程中生成脚本(updater-script)所需要的格式,目前有两种即amend和edify。对应上两种版本升级时会采用不同的解释器。缺省会同时生成两种格式的脚 本。
    -p定义脚本用到的一些可执行文件的路径。
    -s定义额外运行脚本的路径。
    -x定义额外运行的脚本可能用的键值对。
    -v执行过程中打印出执行的命令。
    -h命令帮助

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

if sys.hexversion < 0x02040000:
  print >> sys.stderr, "Python 2.4 or newer is required."
  sys.exit(1)

import copy
import errno
import os
import re
import subprocess
import tempfile
import time
import zipfile

try:
  from hashlib import sha1 as sha1
except ImportError:
  from sha import sha as sha1

import common
import edify_generator

OPTIONS = common.OPTIONS
OPTIONS.package_key = None
OPTIONS.incremental_source = None
OPTIONS.require_verbatim = set()
OPTIONS.prohibit_verbatim = set(("system/build.prop",))
OPTIONS.patch_threshold = 0.95
OPTIONS.wipe_user_data = False
OPTIONS.omit_prereq = False
OPTIONS.extra_script = None
OPTIONS.aslr_mode = True
OPTIONS.worker_threads = 3

def MostPopularKey(d, default):
  """Given a dict, return the key corresponding to the largest
  value.  Returns 'default' if the dict is empty."""
  x = [(v, k) for (k, v) in d.iteritems()]
  if not x: return default
  x.sort()
  return x[-1][1]

def IsSymlink(info):
  """Return true if the zipfile.ZipInfo object passed in represents a
  symlink."""
  return (info.external_attr >> 16) == 0120777

def IsRegular(info):
  """Return true if the zipfile.ZipInfo object passed in represents a
  symlink."""
  return (info.external_attr >> 28) == 010

def ClosestFileMatch(src, tgtfiles, existing):
  """Returns the closest file match between a source file and list
     of potential matches.  The exact filename match is preferred,
     then the sha1 is searched for, and finally a file with the same
     basename is evaluated.  Rename support in the updater-binary is
     required for the latter checks to be used."""

  result = tgtfiles.get("path:" + src.name)
  if result is not None:
    return result


  if not OPTIONS.target_info_dict.get("update_rename_support", False):
    return None


  if src.size < 1000:
    return None

  result = tgtfiles.get("sha1:" + src.sha1)
  if result is not None and existing.get(result.name) is None:
    return result
  result = tgtfiles.get("file:" + src.name.split("/")[-1])
  if result is not None and existing.get(result.name) is None:
    return result
  return None

class Item:
  """Items represent the metadata (user, group, mode) of files and
  directories in the system image."""
  ITEMS = {}
  def __init__(self, name, dir=False):
    self.name = name
    self.uid = None
    self.gid = None
    self.mode = None
    self.selabel = None
    self.capabilities = None
    self.dir = dir

    if name:
      self.parent = Item.Get(os.path.dirname(name), dir=True)
      self.parent.children.append(self)
    else:
      self.parent = None
    if dir:
      self.children = []


  def Dump(self, indent=0):
    if self.uid is not None:
      print "%s%s %d %d %o" % ("  "*indent, self.name, self.uid, self.gid, self.mode)
    else:
      print "%s%s %s %s %s" % ("  "*indent, self.name, self.uid, self.gid, self.mode)
    if self.dir:
      print "%s%s" % ("  "*indent, self.descendants)
      print "%s%s" % ("  "*indent, self.best_subtree)
      for i in self.children:
        i.Dump(indent=indent+1)

  @classmethod
  def Get(cls, name, dir=False):
    if name not in cls.ITEMS:
      cls.ITEMS[name] = Item(name, dir=dir)
    return cls.ITEMS[name]

  @classmethod
  def GetMetadata(cls, input_zip):

    # The target_files contains a record of what the uid,
    # gid, and mode are supposed to be.
    output = input_zip.read("META/filesystem_config.txt")

    for line in output.split("\n"):
      if not line: continue
      columns = line.split()
      name, uid, gid, mode = columns[:4]
      selabel = None
      capabilities = None

      # After the first 4 columns, there are a series of key=value
      # pairs. Extract out the fields we care about.
      for element in columns[4:]:
        key, value = element.split("=")
        if key == "selabel":
          selabel = value
        if key == "capabilities":
          capabilities = value

      i = cls.ITEMS.get(name, None)
      if i is not None:
        i.uid = int(uid)
        i.gid = int(gid)
        i.mode = int(mode, 8)
        i.selabel = selabel
        i.capabilities = capabilities
        if i.dir:
          i.children.sort(key=lambda i: i.name)


    # set metadata for the files generated by this script.
    i = cls.ITEMS.get("system/recovery-from-boot.p", None)
    if i: i.uid, i.gid, i.mode, i.selabel, i.capabilities = 0, 0, 0644, None, None
    i = cls.ITEMS.get("system/etc/install-recovery.sh", None)
    if i: i.uid, i.gid, i.mode, i.selabel, i.capabilities = 0, 0, 0544, None, None

  def CountChildMetadata(self):
    """Count up the (uid, gid, mode, selabel, capabilities) tuples for
    all children and determine the best strategy for using set_perm_recursive and
    set_perm to correctly chown/chmod all the files to their desired
    values.  Recursively calls itself for all descendants.

    Returns a dict of {(uid, gid, dmode, fmode, selabel, capabilities): count} counting up
    all descendants of this node.  (dmode or fmode may be None.)  Also
    sets the best_subtree of each directory Item to the (uid, gid,
    dmode, fmode, selabel, capabilities) tuple that will match the most
    descendants of that Item.
    """

    assert self.dir
    d = self.descendants = {(self.uid, self.gid, self.mode, None, self.selabel, self.capabilities): 1}
    for i in self.children:
      if i.dir:
        for k, v in i.CountChildMetadata().iteritems():
          d[k] = d.get(k, 0) + v
      else:
        k = (i.uid, i.gid, None, i.mode, i.selabel, i.capabilities)
        d[k] = d.get(k, 0) + 1


    # Find the (uid, gid, dmode, fmode, selabel, capabilities)
    # tuple that matches the most descendants.

    # First, find the (uid, gid) pair that matches the most
    # descendants.
    ug = {}
    for (uid, gid, _, _, _, _), count in d.iteritems():
      ug[(uid, gid)] = ug.get((uid, gid), 0) + count
    ug = MostPopularKey(ug, (0, 0))


    # Now find the dmode, fmode, selabel, and capabilities that match
    # the most descendants with that (uid, gid), and choose those.
    best_dmode = (0, 0755)
    best_fmode = (0, 0644)
    best_selabel = (0, None)
    best_capabilities = (0, None)
    for k, count in d.iteritems():
      if k[:2] != ug: continue
      if k[2] is not None and count >= best_dmode[0]: best_dmode = (count, k[2])
      if k[3] is not None and count >= best_fmode[0]: best_fmode = (count, k[3])
      if k[4] is not None and count >= best_selabel[0]: best_selabel = (count, k[4])
      if k[5] is not None and count >= best_capabilities[0]: best_capabilities = (count, k[5])
    self.best_subtree = ug + (best_dmode[1], best_fmode[1], best_selabel[1], best_capabilities[1])

    return d

  def SetPermissions(self, script):
    """Append set_perm/set_perm_recursive commands to 'script' to
    set all permissions, users, and groups for the tree of files
    rooted at 'self'."""

    self.CountChildMetadata()

    def recurse(item, current):
      # current is the (uid, gid, dmode, fmode, selabel, capabilities) tuple that the current
      # item (and all its children) have already been set to.  We only
      # need to issue set_perm/set_perm_recursive commands if we're
      # supposed to be something different.
      if item.dir:
        if current != item.best_subtree:
          script.SetPermissionsRecursive("/"+item.name, *item.best_subtree)
          current = item.best_subtree


        if item.uid != current[0] or item.gid != current[1] or \
           item.mode != current[2] or item.selabel != current[4] or \
           item.capabilities != current[5]:
          script.SetPermissions("/"+item.name, item.uid, item.gid,
                                item.mode, item.selabel, item.capabilities)

        for i in item.children:
          recurse(i, current)
      else:
        if item.uid != current[0] or item.gid != current[1] or \
               item.mode != current[3] or item.selabel != current[4] or \
               item.capabilities != current[5]:
          script.SetPermissions("/"+item.name, item.uid, item.gid,
                                item.mode, item.selabel, item.capabilities)

    recurse(self, (-1, -1, -1, -1, None, None))


def CopySystemFiles(input_zip, output_zip=None,
                    substitute=None):
  """Copies files underneath system/ in the input zip to the output
  zip.  Populates the Item class with their metadata, and returns a
  list of symlinks.  output_zip may be None, in which case the copy is
  skipped (but the other side effects still happen).  substitute is an
  optional dict of {output filename: contents} to be output instead of
  certain input files.
  """

  symlinks = []

  for info in input_zip.infolist():
    if info.filename.startswith("SYSTEM/"):
      basefilename = info.filename[7:]
      if IsSymlink(info):
        symlinks.append((input_zip.read(info.filename),
                         "/system/" + basefilename))
      else:
        info2 = copy.copy(info)
        fn = info2.filename = "system/" + basefilename
        if substitute and fn in substitute and substitute[fn] is None:
          continue
        if output_zip is not None:
          if substitute and fn in substitute:
            data = substitute[fn]
          else:
            data = input_zip.read(info.filename)
          output_zip.writestr(info2, data)
        if fn.endswith("/"):
          Item.Get(fn[:-1], dir=True)
        else:
          Item.Get(fn, dir=False)

  symlinks.sort()
  return symlinks

def SignOutput(temp_zip_name, output_zip_name):
  key_passwords = common.GetKeyPasswords([OPTIONS.package_key])
  pw = key_passwords[OPTIONS.package_key]
  common.SignFile(temp_zip_name, output_zip_name, OPTIONS.package_key, pw,
                  whole_file=True)

def AppendAssertions(script, info_dict):
  device = GetBuildProp("ro.product.device", info_dict)
  script.AssertDevice(device)


def MakeecoveryPatch(input_tmp, output_zip, recovery_img, boot_img):
  """Generate a binary patch that creates the recovery image starting
  with the boot image.  (Most of the space in these images is just the
  kernel, which is identical for the two, so the resulting patch
  should be efficient.)  Add it to the output zip, along with a shell
  script that is run from init.rc on first boot to actually do the
  patching and install the new recovery image.

  recovery_img and boot_img should be File objects for the
  corresponding images.  info should be the dictionary returned by
  common.LoadInfoDict() on the input target_files.


  Returns an Item for the shell script, which must be made
  executable.
  """


  diff_program = ["imgdiff"]
  path = os.path.join(input_tmp, "SYSTEM", "etc", "recovery-resource.dat")
  if os.path.exists(path):
    diff_program.append("-b")
    diff_program.append(path)
    bonus_args = "-b /system/etc/recovery-resource.dat"
  else:
    bonus_args = ""


  d = common.Difference(recovery_img, boot_img, diff_program=diff_program)
  _, _, patch = d.ComputePatch()
  common.ZipWriteStr(output_zip, "recovery/recovery-from-boot.p", patch)
  Item.Get("system/recovery-from-boot.p", dir=False)


  boot_type, boot_device = common.GetTypeAndDevice("/boot", OPTIONS.info_dict)
  recovery_type, recovery_device = common.GetTypeAndDevice("/recovery", OPTIONS.info_dict)


  sh = """#!/system/bin/sh
if ! applypatch -c %(recovery_type)s:%(recovery_device)s:%(recovery_size)d:%(recovery_sha1)s; then
  log -t recovery "Installing new recovery image"
  applypatch %(bonus_args)s %(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
else
  log -t recovery "Recovery image already installed"
fi
""" % { 'boot_size': boot_img.size,
        'boot_sha1': boot_img.sha1,
        'recovery_size': recovery_img.size,
        'recovery_sha1': recovery_img.sha1,
        'boot_type': boot_type,
        'boot_device': boot_device,
        'recovery_type': recovery_type,
        'recovery_device': recovery_device,
        'bonus_args': bonus_args,
        }
  common.ZipWriteStr(output_zip, "recovery/etc/install-recovery.sh", sh)
  return Item.Get("system/etc/install-recovery.sh", dir=False)


def WriteFullOTAPackage(input_zip, output_zip):
  # TODO: how to determine this?  We don't know what version it will
  # be installed on top of.  For now, we expect the API just won't
  # change very often.
  script = edify_generator.EdifyGenerator(3, OPTIONS.info_dict)


  metadata = {"post-build": GetBuildProp("ro.build.fingerprint",
                                         OPTIONS.info_dict),
              "pre-device": GetBuildProp("ro.product.device",
                                         OPTIONS.info_dict),
              "post-timestamp": GetBuildProp("ro.build.date.utc",
                                             OPTIONS.info_dict),
              }


  device_specific = common.DeviceSpecificParams(
      input_zip=input_zip,
      input_version=OPTIONS.info_dict["recovery_api_version"],
      output_zip=output_zip,
      script=script,
      input_tmp=OPTIONS.input_tmp,
      metadata=metadata,
      info_dict=OPTIONS.info_dict)

  if not OPTIONS.omit_prereq:
    ts = GetBuildProp("ro.build.date.utc", OPTIONS.info_dict)
    ts_text = GetBuildProp("ro.build.date", OPTIONS.info_dict)
    script.AssertOlderBuild(ts, ts_text)

  AppendAssertions(script, OPTIONS.info_dict)
  device_specific.FullOTA_Assertions()
  device_specific.FullOTA_InstallBegin()


  script.ShowProgress(0.5, 0)


  if OPTIONS.wipe_user_data:
    script.FormatPartition("/data")


  if "selinux_fc" in OPTIONS.info_dict:
    WritePolicyConfig(OPTIONS.info_dict["selinux_fc"], output_zip)


  script.FormatPartition("/system")
  script.Mount("/system")
  script.UnpackPackageDir("recovery", "/system")
  script.UnpackPackageDir("system", "/system")


  symlinks = CopySystemFiles(input_zip, output_zip)
  script.MakeSymlinks(symlinks)


  boot_img = common.GetBootableImage("boot.img", "boot.img",
                                     OPTIONS.input_tmp, "BOOT")
  recovery_img = common.GetBootableImage("recovery.img", "recovery.img",
                                         OPTIONS.input_tmp, "RECOVERY")
  MakeRecoveryPatch(OPTIONS.input_tmp, output_zip, recovery_img, boot_img)


  Item.GetMetadata(input_zip)
  Item.Get("system").SetPermissions(script)


  common.CheckSize(boot_img.data, "boot.img", OPTIONS.info_dict)
  common.ZipWriteStr(output_zip, "boot.img", boot_img.data)
  script.ShowProgress(0.2, 0)


  script.ShowProgress(0.2, 10)
  script.WriteRawImage("/boot", "boot.img")


  script.ShowProgress(0.1, 0)
  device_specific.FullOTA_InstallEnd()


  if OPTIONS.extra_script is not None:
    script.AppendExtra(OPTIONS.extra_script)


  script.UnmountAll()
  script.AddToZip(input_zip, output_zip)
  WriteMetadata(metadata, output_zip)


def WritePolicyConfig(file_context, output_zip):
  f = open(file_context, 'r');
  basename = os.path.basename(file_context)
  common.ZipWriteStr(output_zip, basename, f.read())




def WriteMetadata(metadata, output_zip):
  common.ZipWriteStr(output_zip, "META-INF/com/android/metadata",
                     "".join(["%s=%s\n" % kv
                              for kv in sorted(metadata.iteritems())]))


def LoadSystemFiles(z):
  """Load all the files from SYSTEM/... in a given target-files
  ZipFile, and return a dict of {filename: File object}."""
  out = {}
  for info in z.infolist():
    if info.filename.startswith("SYSTEM/") and not IsSymlink(info):
      basefilename = info.filename[7:]
      fn = "system/" + basefilename
      data = z.read(info.filename)
      out[fn] = common.File(fn, data)
  return out




def GetBuildProp(prop, info_dict):
  """Return the fingerprint of the build of a given target-files info_dict."""
  try:
    return info_dict.get("build.prop", {})[prop]
  except KeyError:
    raise common.ExternalError("couldn't find %s in build.prop" % (property,))




def WriteIncrementalOTAPackage(target_zip, source_zip, output_zip):
  source_version = OPTIONS.source_info_dict["recovery_api_version"]
  target_version = OPTIONS.target_info_dict["recovery_api_version"]


  if source_version == 0:
    print ("WARNING: generating edify script for a source that "
           "can't install it.")
  script = edify_generator.EdifyGenerator(source_version,
                                          OPTIONS.target_info_dict)


  metadata = {"pre-device": GetBuildProp("ro.product.device",
                                         OPTIONS.source_info_dict),
              "post-timestamp": GetBuildProp("ro.build.date.utc",
                                             OPTIONS.target_info_dict),
              }

  device_specific = common.DeviceSpecificParams(
      source_zip=source_zip,
      source_version=source_version,
      target_zip=target_zip,
      target_version=target_version,
      output_zip=output_zip,
      script=script,
      metadata=metadata,
      info_dict=OPTIONS.info_dict)

  print "Loading target..."
  target_data = LoadSystemFiles(target_zip)
  print "Loading source..."
  source_data = LoadSystemFiles(source_zip)


  verbatim_targets = []
  patch_list = []
  diffs = []
  renames = {}
  largest_source_size = 0

  matching_file_cache = {}
  for fn in source_data.keys():
    sf = source_data[fn]
    assert fn == sf.name
    matching_file_cache["path:" + fn] = sf
    # Only allow eligability for filename/sha matching
    # if there isn't a perfect path match.
    if target_data.get(sf.name) is None:
      matching_file_cache["file:" + fn.split("/")[-1]] = sf
      matching_file_cache["sha:" + sf.sha1] = sf


  for fn in sorted(target_data.keys()):
    tf = target_data[fn]
    assert fn == tf.name
    sf = ClosestFileMatch(tf, matching_file_cache, renames)
    if sf is not None and sf.name != tf.name:
      print "File has moved from " + sf.name + " to " + tf.name
      renames[sf.name] = tf


    if sf is None or fn in OPTIONS.require_verbatim:
      # This file should be included verbatim
      if fn in OPTIONS.prohibit_verbatim:
        raise common.ExternalError("\"%s\" must be sent verbatim" % (fn,))
      print "send", fn, "verbatim"
      tf.AddToZip(output_zip)
      verbatim_targets.append((fn, tf.size))
    elif tf.sha1 != sf.sha1:
      # File is different; consider sending as a patch
      diffs.append(common.Difference(tf, sf))
    else:
      # Target file data identical to source (may still be renamed)
      pass


  common.ComputeDifferences(diffs)

  for diff in diffs:
    tf, sf, d = diff.GetPatch()
    if d is None or len(d) > tf.size * OPTIONS.patch_threshold:
      # patch is almost as big as the file; don't bother patching
      tf.AddToZip(output_zip)
      verbatim_targets.append((tf.name, tf.size))
    else:
      common.ZipWriteStr(output_zip, "patch/" + sf.name + ".p", d)
      patch_list.append((sf.name, tf, sf, tf.size, common.sha1(d).hexdigest()))
      largest_source_size = max(largest_source_size, sf.size)


  source_fp = GetBuildProp("ro.build.fingerprint", OPTIONS.source_info_dict)
  target_fp = GetBuildProp("ro.build.fingerprint", OPTIONS.target_info_dict)
  metadata["pre-build"] = source_fp
  metadata["post-build"] = target_fp


  script.Mount("/system")
  script.AssertSomeFingerprint(source_fp, target_fp)


  source_boot = common.GetBootableImage(
      "/tmp/boot.img", "boot.img", OPTIONS.source_tmp, "BOOT",
      OPTIONS.source_info_dict)
  target_boot = common.GetBootableImage(
      "/tmp/boot.img", "boot.img", OPTIONS.target_tmp, "BOOT")
  updating_boot = (source_boot.data != target_boot.data)


  source_recovery = common.GetBootableImage(
      "/tmp/recovery.img", "recovery.img", OPTIONS.source_tmp, "RECOVERY",
      OPTIONS.source_info_dict)
  target_recovery = common.GetBootableImage(
      "/tmp/recovery.img", "recovery.img", OPTIONS.target_tmp, "RECOVERY")
  updating_recovery = (source_recovery.data != target_recovery.data)


  # Here's how we divide up the progress bar:
  #  0.1 for verifying the start state (PatchCheck calls)
  #  0.8 for applying patches (ApplyPatch calls)
  #  0.1 for unpacking verbatim files, symlinking, and doing the
  #      device-specific commands.


  AppendAssertions(script, OPTIONS.target_info_dict)
  device_specific.IncrementalOTA_Assertions()


  script.Print("Verifying current system...")


  device_specific.IncrementalOTA_VerifyBegin()


  script.ShowProgress(0.1, 0)
  total_verify_size = float(sum([i[2].size for i in patch_list]) + 1)
  if updating_boot:
    total_verify_size += source_boot.size
  so_far = 0


  for fn, tf, sf, size, patch_sha in patch_list:
    script.PatchCheck("/"+fn, tf.sha1, sf.sha1)
    so_far += sf.size
    script.SetProgress(so_far / total_verify_size)


  if updating_boot:
    d = common.Difference(target_boot, source_boot)
    _, _, d = d.ComputePatch()
    print "boot      target: %d  source: %d  diff: %d" % (
        target_boot.size, source_boot.size, len(d))


    common.ZipWriteStr(output_zip, "patch/boot.img.p", d)


    boot_type, boot_device = common.GetTypeAndDevice("/boot", OPTIONS.info_dict)


    script.PatchCheck("%s:%s:%d:%s:%d:%s" %
                      (boot_type, boot_device,
                       source_boot.size, source_boot.sha1,
                       target_boot.size, target_boot.sha1))
    so_far += source_boot.size
    script.SetProgress(so_far / total_verify_size)


  if patch_list or updating_recovery or updating_boot:
    script.CacheFreeSpaceCheck(largest_source_size)


  device_specific.IncrementalOTA_VerifyEnd()


  script.Comment("---- start making changes here ----")


  device_specific.IncrementalOTA_InstallBegin()


  if OPTIONS.wipe_user_data:
    script.Print("Erasing user data...")
    script.FormatPartition("/data")


  script.Print("Removing unneeded files...")
  script.DeleteFiles(["/"+i[0] for i in verbatim_targets] +
                     ["/"+i for i in sorted(source_data)
                            if i not in target_data and
                            i not in renames] +
                     ["/system/recovery.img"])


  script.ShowProgress(0.8, 0)
  total_patch_size = float(sum([i[1].size for i in patch_list]) + 1)
  if updating_boot:
    total_patch_size += target_boot.size
  so_far = 0


  script.Print("Patching system files...")
  deferred_patch_list = []
  for item in patch_list:
    fn, tf, sf, size, _ = item
    if tf.name == "system/build.prop":
      deferred_patch_list.append(item)
      continue
    script.ApplyPatch("/"+fn, "-", tf.size, tf.sha1, sf.sha1, "patch/"+fn+".p")
    so_far += tf.size
    script.SetProgress(so_far / total_patch_size)


  if updating_boot:
    # Produce the boot image by applying a patch to the current
    # contents of the boot partition, and write it back to the
    # partition.
    script.Print("Patching boot image...")
    script.ApplyPatch("%s:%s:%d:%s:%d:%s"
                      % (boot_type, boot_device,
                         source_boot.size, source_boot.sha1,
                         target_boot.size, target_boot.sha1),
                      "-",
                      target_boot.size, target_boot.sha1,
                      source_boot.sha1, "patch/boot.img.p")
    so_far += target_boot.size
    script.SetProgress(so_far / total_patch_size)
    print "boot image changed; including."
  else:
    print "boot image unchanged; skipping."


  if updating_recovery:
    # Recovery is generated as a patch using both the boot image
    # (which contains the same linux kernel as recovery) and the file
    # /system/etc/recovery-resource.dat (which contains all the images
    # used in the recovery UI) as sources.  This lets us minimize the
    # size of the patch, which must be included in every OTA package.
    #
    # For older builds where recovery-resource.dat is not present, we
    # use only the boot image as the source.


    MakeRecoveryPatch(OPTIONS.target_tmp, output_zip,
                      target_recovery, target_boot)
    script.DeleteFiles(["/system/recovery-from-boot.p",
                        "/system/etc/install-recovery.sh"])
    print "recovery image changed; including as patch from boot."
  else:
    print "recovery image unchanged; skipping."


  script.ShowProgress(0.1, 10)


  target_symlinks = CopySystemFiles(target_zip, None)


  target_symlinks_d = dict([(i[1], i[0]) for i in target_symlinks])
  temp_script = script.MakeTemporary()
  Item.GetMetadata(target_zip)
  Item.Get("system").SetPermissions(temp_script)


  # Note that this call will mess up the tree of Items, so make sure
  # we're done with it.
  source_symlinks = CopySystemFiles(source_zip, None)
  source_symlinks_d = dict([(i[1], i[0]) for i in source_symlinks])


  # Delete all the symlinks in source that aren't in target.  This
  # needs to happen before verbatim files are unpacked, in case a
  # symlink in the source is replaced by a real file in the target.
  to_delete = []
  for dest, link in source_symlinks:
    if link not in target_symlinks_d:
      to_delete.append(link)
  script.DeleteFiles(to_delete)


  if verbatim_targets:
    script.Print("Unpacking new files...")
    script.UnpackPackageDir("system", "/system")


  if updating_recovery:
    script.Print("Unpacking new recovery...")
    script.UnpackPackageDir("recovery", "/system")


  if len(renames) > 0:
    script.Print("Renaming files...")


  for src in renames:
    print "Renaming " + src + " to " + renames[src].name
    script.RenameFile(src, renames[src].name)


  script.Print("Symlinks and permissions...")


  # Create all the symlinks that don't already exist, or point to
  # somewhere different than what we want.  Delete each symlink before
  # creating it, since the 'symlink' command won't overwrite.
  to_create = []
  for dest, link in target_symlinks:
    if link in source_symlinks_d:
      if dest != source_symlinks_d[link]:
        to_create.append((dest, link))
    else:
      to_create.append((dest, link))
  script.DeleteFiles([i[1] for i in to_create])
  script.MakeSymlinks(to_create)


  # Now that the symlinks are created, we can set all the
  # permissions.
  script.AppendScript(temp_script)


  # Do device-specific installation (eg, write radio image).
  device_specific.IncrementalOTA_InstallEnd()


  if OPTIONS.extra_script is not None:
    script.AppendExtra(OPTIONS.extra_script)


  # Patch the build.prop file last, so if something fails but the
  # device can still come up, it appears to be the old build and will
  # get set the OTA package again to retry.
  script.Print("Patching remaining system files...")
  for item in deferred_patch_list:
    fn, tf, sf, size, _ = item
    script.ApplyPatch("/"+fn, "-", tf.size, tf.sha1, sf.sha1, "patch/"+fn+".p")
  script.SetPermissions("/system/build.prop", 0, 0, 0644, None, None)

  script.AddToZip(target_zip, output_zip)
  WriteMetadata(metadata, output_zip)



def main(argv):


  def option_handler(o, a):
    if o in ("-b", "--board_config"):
      pass   # deprecated
    elif o in ("-k", "--package_key"):
      OPTIONS.package_key = a
    elif o in ("-i", "--incremental_from"):
      OPTIONS.incremental_source = a
    elif o in ("-w", "--wipe_user_data"):
      OPTIONS.wipe_user_data = True
    elif o in ("-n", "--no_prereq"):
      OPTIONS.omit_prereq = True
    elif o in ("-e", "--extra_script"):
      OPTIONS.extra_script = a
    elif o in ("-a", "--aslr_mode"):
      if a in ("on", "On", "true", "True", "yes", "Yes"):
        OPTIONS.aslr_mode = True
      else:
        OPTIONS.aslr_mode = False
    elif o in ("--worker_threads"):
      OPTIONS.worker_threads = int(a)
    else:
      return False
    return True


  args = common.ParseOptions(argv, __doc__,
                             extra_opts="b:k:i:d:wne:a:",
                             extra_long_opts=["board_config=",
                                              "package_key=",
                                              "incremental_from=",
                                              "wipe_user_data",
                                              "no_prereq",
                                              "extra_script=",
                                              "worker_threads=",
                                              "aslr_mode=",
                                              ],
                             extra_option_handler=option_handler)


  if len(args) != 2:
    common.Usage(__doc__)
    sys.exit(1)


  if OPTIONS.extra_script is not None:
    OPTIONS.extra_script = open(OPTIONS.extra_script).read()


  print "unzipping target target-files..."
  OPTIONS.input_tmp, input_zip = common.UnzipTemp(args[0])


  OPTIONS.target_tmp = OPTIONS.input_tmp
  OPTIONS.info_dict = common.LoadInfoDict(input_zip)


  # If this image was originally labelled with SELinux contexts, make sure we
  # also apply the labels in our new image. During building, the "file_contexts"
  # is in the out/ directory tree, but for repacking from target-files.zip it's
  # in the root directory of the ramdisk.
  if "selinux_fc" in OPTIONS.info_dict:
    OPTIONS.info_dict["selinux_fc"] = os.path.join(OPTIONS.input_tmp, "BOOT", "RAMDISK",
        "file_contexts")


  if OPTIONS.verbose:
    print "--- target info ---"
    common.DumpInfoDict(OPTIONS.info_dict)


  if OPTIONS.device_specific is None:
    OPTIONS.device_specific = OPTIONS.info_dict.get("tool_extensions", None)
  if OPTIONS.device_specific is not None:
    OPTIONS.device_specific = os.path.normpath(OPTIONS.device_specific)
    print "using device-specific extensions in", OPTIONS.device_specific


  temp_zip_file = tempfile.NamedTemporaryFile()
  output_zip = zipfile.ZipFile(temp_zip_file, "w",
                               compression=zipfile.ZIP_DEFLATED)


  if OPTIONS.incremental_source is None:
    WriteFullOTAPackage(input_zip, output_zip)
    if OPTIONS.package_key is None:
      OPTIONS.package_key = OPTIONS.info_dict.get(
          "default_system_dev_certificate",
          "build/target/product/security/testkey")
  else:
    print "unzipping source target-files..."
    OPTIONS.source_tmp, source_zip = common.UnzipTemp(OPTIONS.incremental_source)
    OPTIONS.target_info_dict = OPTIONS.info_dict
    OPTIONS.source_info_dict = common.LoadInfoDict(source_zip)
    if OPTIONS.package_key is None:
      OPTIONS.package_key = OPTIONS.source_info_dict.get(
          "default_system_dev_certificate",
          "build/target/product/security/testkey")
    if OPTIONS.verbose:
      print "--- source info ---"
      common.DumpInfoDict(OPTIONS.source_info_dict)
    WriteIncrementalOTAPackage(input_zip, source_zip, output_zip)

  output_zip.close()

  SignOutput(temp_zip_file.name, args[1])
  temp_zip_file.close()

  common.Cleanup()

  print "done."

if __name__ == '__main__':
  try:
    common.CloseInheritedPipes()
    main(sys.argv[1:])
  except common.ExternalError, e:
    print
    print "   ERROR: %s" % (e,)
    print
    sys.exit(1)				   </span>
主函数main是python的入口函数,我们从main函数开始看,大概看一下main函数(脚本最后)里的流程就能知道脚本的执行过程了。
    1) 在main函数的开头,首先将用户设定的option选项存入OPTIONS变量中,它是一个python中的类。紧接着判断有没有额外的脚本,如果有就读入到OPTIONS变量中。
    2) 解压缩输入的zip包,即我们在上文生成的原始zip包。然后判断是否用到device-specific extensions(设备扩展)如果用到,随即读入到OPTIONS变量中。
    3) 判断是否签名,然后判断是否有新内容的增量源,有的话就解压该增量源包放入一个临时变量中(source_zip)。自此,所有的准备工作已完毕,随即会调用该脚本中最主要的函数WriteFullOTAPackage(input_zip,output_zip)
    4) WriteFullOTAPackage函数的处理过程是先获得脚本的生成器。默认格式是edify。然后获得metadata元数据,此数据来至于Android的一些环境变量。然后获得设备配置参数比如api函数的版本。然后判断是否忽略时间戳。
    5) WriteFullOTAPackage函数做完准备工作后就开始生成升级用的脚本文件(updater-script)了。生成脚本文件后将上一步获得的metadata元数据写入到输出包out_zip。

    6) 至此一个完整的update.zip升级包就生成了。生成位置在:out/target/product/tcc8800/full_tcc8800_evm-ota-eng.mumu.20120315.155326.zip。将升级包拷贝到SD卡中就可以用来升级了。

  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
华为HG255d刷机工具及固件大全.zip是一个包含华为HG255d路由器刷机工具和固件的压缩文件。刷机工具和固件是为了提高华为HG255d路由器的性能和功能而开发的。 刷机是指将原始的固件替换为更新版本的过程,这样可以解锁更多的功能,并修复一些可能存在的问题。刷机工具是用来执行这个过程的软件。 固件是路由器上运行的操作系统,它控制着路由器的各种功能,如连接、安全性和设置等。对于华为HG255d路由器,固件的更新可以提高其稳定性和性能,修复安全漏洞,并增加新的功能。 华为HG255d刷机工具及固件大全.zip将刷机工具和各种固件收集在一起,方便用户根据自己的需求选择适合的固件进行刷机。这样用户可以根据自己的需求选择固件版本,如稳定版、测试版或者其他自定义版本。 在使用刷机工具和固件时,需要注意以下几点: 1. 刷机有一定的风险,如果操作不当可能会造成设备损坏,建议在充分了解刷机过程和风险的情况下进行操作。 2. 在刷机之前,应备份好路由器上的重要数据以防丢失。 3. 如果不确定如何选择固件版本或者如何操作,请参考相关的刷机教程或者咨询专业人士的意见。 总之,华为HG255d刷机工具及固件大全.zip是一个便捷的资源,可以帮助用户提升华为HG255d路由器的性能和功能。但在使用之前请注意一些风险和注意事项。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值