Android系統Recovery工作原理之使用update.zip升級過程分析

時間  2021-07-13
欄目 Android 简体版
原文   原文鏈接

轉載自  http://blog.csdn.net/mu0206mu


         這篇及以後的篇幅將通過分析update.zip包在具體Android系統升級的過程，來理解Android系統中Recovery模式服務的工作原理。我們先從update.zip包的製作開始，然後是Android系統的啓動模式分析，Recovery工作原理，如何從我們上層開始選擇system update到重啓到Recovery服務，以及在Recovery服務中具體怎樣處理update.zip包升級的，我們的安裝腳本updater-script怎樣被解析並執行的等一系列問題。分析過程中所用的Android源碼是gingerbread0919（tcc88xx開發板標配的），測試開發板是tcc88xx。這是在工作中總結的文檔，當然在網上參考了不少內容，如有雷同純屬巧合吧，在分析過程中也存在很多未解決的問題，也希望大家不吝指教。


一、 update.zip包的目錄結構
          |----boot.img
          |----system/
          |----recovery/
                `|----recovery-from-boot.p
                `|----etc/
                        `|----install-recovery.sh
          |---META-INF/
              `|CERT.RSA
              `|CERT.SF
              `|MANIFEST.MF
              `|----com/
                     `|----google/
                             `|----android/
                                    `|----update-binary
                                    `|----updater-script
                             `|----android/
                                    `|----metadata
二、 update.zip包目錄結構詳解
         以上是我們用命令make otapackage 製作的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代表簽名者。
        另外，在具體升級時，對update.zip包檢查時大致會分三步：①檢驗SF文件與RSA文件是否匹配。②檢驗MANIFEST.MF與簽名文件中的digest是否一致。③檢驗包中的文件與MANIFEST中所描述的是否一致。
三、 Android升級包update.zip的生成過程分析

         1) 對於update.zip包的製作有兩種方式，即手動製作和命令生成。

          第一種手動製作：即按照update.zip的目錄結構手動創建我們需要的目錄。然後將對應的文件拷貝到相應的目錄下，比如我們向系統中新加一個應用程序。可以將新增的應用拷貝到我們新建的update/system/app/下（system目錄是事先拷貝編譯源碼後生成的system目錄），打包並簽名後，拷貝到SD卡就可以使用了。這種方式在實際的tcc8800開發板中未測試成功。簽名部分未通過，可能與具體的開發板相關。

          第二種製作方式：命令製作。Android源碼系統中爲我們提供了製作update.zip刷機包的命令，即make otapackage。該命令在編譯源碼完成後並在源碼根目錄下執行。 具體操作方式：在源碼根目錄下執行

                ①$ . build/envsetup.sh。 

                ②$ lunch 然後選擇你需要的配置(如17)。

                ③$ make otapackage。

          在編譯完源碼後最好再執行一遍上面的①、②步防止執行③時出現未找到對應規則的錯誤提示。命令執行完成後生成的升級包所在位置在out/target/product/full_tcc8800_evm_target_files-eng.mumu.20120309.111059.zip將這個包重新命名爲update.zip，並拷貝到SD卡中即可使用。

           這種方式(即完全升級)在tcc8800開發板中已測試成功。

       2) 使用make otapackage命令生成update.zip的過程分析。
            在源碼根目錄下執行make otapackage命令生成update.zip包主要分爲兩步，第一步是根據Makefile執行編譯生成一個update原包（zip格式）。第二步是運行一個python腳本，並以上一步準備的zip包作爲輸入，最終生成我們需要的升級包。下面進一步分析這兩個過程。

            第一步：編譯Makefile。對應的Makefile文件所在位置：build/core/Makefile。從該文件的884行（tcc8800,gingerbread0919）開始會生成一個zip包，這個包最後會用來製作OTA package 或者filesystem image。先將這部分的對應的Makefile貼出來如下：


[python]  view plain  copy
  1. # -----------------------------------------------------------------    
  2. # A zip of the directories that map to the target filesystem.    
  3. # This zip can be used to create an OTA package or filesystem image    
  4. # as a post-build step.    
  5. #    
  6. name := $(TARGET_PRODUCT)    
  7. ifeq ($(TARGET_BUILD_TYPE),debug)    
  8.   name := $(name)_debug    
  9. endif    
  10. name := $(name)-target_files-$(FILE_NAME_TAG)    
  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. # $(1): Directory to copy    
  19. # $(2): Location to copy it to    
  20. # The "ls -A" is to prevent "acp s/* d" from failing if s is empty.    
  21. define package_files-copy-root    
  22.   if [ -d "$(strip $(1))" -a "$$(ls -A $(1))" ]; then \    
  23.     mkdir -p $(2) && \    
  24.     $(ACP) -rd $(strip $(1))/* $(2); \    
  25.   fi    
  26. endef    
  27.     
  28. built_ota_tools := \    
  29.     $(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \    
  30.     $(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \    
  31.     $(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \    
  32.     $(call intermediates-dir-for,EXECUTABLES,updater)/updater    
  33. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)    
  34.     
  35. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_VERSION)    
  36.     
  37. ifeq ($(TARGET_RELEASETOOLS_EXTENSIONS),)    
  38. # default to common dir for device vendor    
  39. $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_DEVICE_DIR)/../common    
  40. else    
  41. $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_RELEASETOOLS_EXTENSIONS)    
  42. endif    
  43.     
  44. # Depending on the various images guarantees that the underlying    
  45. # directories are up-to-date.    
  46. $(BUILT_TARGET_FILES_PACKAGE): \    
  47.         $(INSTALLED_BOOTIMAGE_TARGET) \    
  48.         $(INSTALLED_RADIOIMAGE_TARGET) \    
  49.         $(INSTALLED_RECOVERYIMAGE_TARGET) \    
  50.         $(INSTALLED_SYSTEMIMAGE) \    
  51.         $(INSTALLED_USERDATAIMAGE_TARGET) \    
  52.         $(INSTALLED_ANDROID_INFO_TXT_TARGET) \    
  53.         $(built_ota_tools) \    
  54.         $(APKCERTS_FILE) \    
  55.         $(HOST_OUT_EXECUTABLES)/fs_config \    
  56.         | $(ACP)    
  57.     @echo "Package target files: [email protected]"    
  58.     $(hide) rm -rf [email protected] $(zip_root)    
  59.     $(hide) mkdir -p $(dir [email protected]) $(zip_root)    
  60.     @# Components of the recovery image    
  61.     $(hide) mkdir -p $(zip_root)/RECOVERY    
  62.     $(hide) $(call package_files-copy-root, \    
  63.         $(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)    
  64. ifdef INSTALLED_KERNEL_TARGET    
  65.     $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/RECOVERY/kernel    
  66. endif    
  67. ifdef INSTALLED_2NDBOOTLOADER_TARGET    
  68.     $(hide) $(ACP) \    
  69.         $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/RECOVERY/second    
  70. endif    
  71. ifdef BOARD_KERNEL_CMDLINE    
  72.     $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/RECOVERY/cmdline    
  73. endif    
  74. ifdef BOARD_KERNEL_BASE    
  75.     $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/RECOVERY/base    
  76. endif    
  77. ifdef BOARD_KERNEL_PAGESIZE    
  78.     $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/RECOVERY/pagesize    
  79. endif    
  80.     @# Components of the boot image    
  81.     $(hide) mkdir -p $(zip_root)/BOOT    
  82.     $(hide) $(call package_files-copy-root, \    
  83.         $(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)    
  84. ifdef INSTALLED_KERNEL_TARGET    
  85.     $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/BOOT/kernel    
  86. endif    
  87. ifdef INSTALLED_2NDBOOTLOADER_TARGET    
  88.     $(hide) $(ACP) \    
  89.         $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/BOOT/second    
  90. endif    
  91. ifdef BOARD_KERNEL_CMDLINE    
  92.     $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/BOOT/cmdline    
  93. endif    
  94. ifdef BOARD_KERNEL_BASE    
  95.     $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/BOOT/base    
  96. endif    
  97. ifdef BOARD_KERNEL_PAGESIZE    
  98.     $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/BOOT/pagesize    
  99. endif    
  100.     $(hide) $(foreach t,$(INSTALLED_RADIOIMAGE_TARGET),\    
  101.                 mkdir -p $(zip_root)/RADIO; \    
  102.                 $(ACP) $(t) $(zip_root)/RADIO/$(notdir $(t));)    
  103.     @# Contents of the system image    
  104.     $(hide) $(call package_files-copy-root, \    
  105.         $(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)    
  106.     @# Contents of the data image    
  107.     $(hide) $(call package_files-copy-root, \    
  108.         $(TARGET_OUT_DATA),$(zip_root)/DATA)    
  109.     @# Extra contents of the OTA package    
  110.     $(hide) mkdir -p $(zip_root)/OTA/bin    
  111.     $(hide) $(ACP) $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/    
  112.     $(hide) $(ACP) $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/    
  113.     @# Files that do not end up in any images, but are necessary to    
  114.     @# build them.    
  115.     $(hide) mkdir -p $(zip_root)/META    
  116.     $(hide) $(ACP) $(APKCERTS_FILE) $(zip_root)/META/apkcerts.txt    
  117.     $(hide) echo "$(PRODUCT_OTA_PUBLIC_KEYS)" > $(zip_root)/META/otakeys.txt    
  118.     $(hide) echo "recovery_api_version=$(PRIVATE_RECOVERY_API_VERSION)" > $(zip_root)/META/misc_info.txt    
  119. ifdef BOARD_FLASH_BLOCK_SIZE    
  120.     $(hide) echo "blocksize=$(BOARD_FLASH_BLOCK_SIZE)" >> $(zip_root)/META/misc_info.txt    
  121. endif    
  122. ifdef BOARD_BOOTIMAGE_PARTITION_SIZE    
  123.     $(hide) echo "boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt    
  124. endif    
  125. ifdef BOARD_RECOVERYIMAGE_PARTITION_SIZE    
  126.     $(hide) echo "recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt    
  127. endif    
  128. ifdef BOARD_SYSTEMIMAGE_PARTITION_SIZE    
  129.     $(hide) echo "system_size=$(BOARD_SYSTEMIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt    
  130. endif    
  131. ifdef BOARD_USERDATAIMAGE_PARTITION_SIZE    
  132.     $(hide) echo "userdata_size=$(BOARD_USERDATAIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt    
  133. endif    
  134.     $(hide) echo "tool_extensions=$(tool_extensions)" >> $(zip_root)/META/misc_info.txt    
  135. ifdef mkyaffs2_extra_flags    
  136.     $(hide) echo "mkyaffs2_extra_flags=$(mkyaffs2_extra_flags)" >> $(zip_root)/META/misc_info.txt    
  137. endif    
  138.     @# Zip everything up, preserving symlinks    
  139.     $(hide) (cd $(zip_root) && zip -qry ../$(notdir [email protected]) .)    
  140.     @# Run fs_config on all the system files in the zip, and save the output    
  141.     $(hide) zipinfo -1 [email protected] | awk -F/ 'BEGIN { OFS="/" } /^SYSTEM\// {$$1 = "system"; print}' | $(HOST_OUT_EXECUTABLES)/fs_config > $(zip_root)/META/filesystem_config.txt    
  142.     $(hide) (cd $(zip_root) && zip -q ../$(notdir [email protected]) META/filesystem_config.txt)    
  143.     
  144.     
  145. target-files-package: $(BUILT_TARGET_FILES_PACKAGE)    
  146.     
  147.     
  148. ifneq ($(TARGET_SIMULATOR),true)    
  149. ifneq ($(TARGET_PRODUCT),sdk)    
  150. ifneq ($(TARGET_DEVICE),generic)    
  151. ifneq ($(TARGET_NO_KERNEL),true)    
  152. ifneq ($(recovery_fstab),)    


            根據上面的Makefile可以分析這個包的生成過程：

            首先創建一個root_zip根目錄，並依次在此目錄下創建所需要的如下其他目錄

            ①創建RECOVERY目錄，並填充該目錄的內容，包括kernel的鏡像和recovery根文件系統的鏡像。此目錄最終用於生成recovery.img。

            ②創建並填充BOOT目錄。包含kernel和cmdline以及pagesize大小等，該目錄最終用來生成boot.img。
            ③向SYSTEM目錄填充system image。
            ④向DATA填充data image。
            ⑤用於生成OTA package包所需要的額外的內容。主要包括一些bin命令。
            ⑥創建META目錄並向該目錄下添加一些文本文件，如apkcerts.txt(描述apk文件用到的認證證書)，misc_info.txt(描述Flash內存的塊大小以及boot、recovery、system、userdata等分區的大小信息)。
            ⑦使用保留連接選項壓縮我們在上面獲得的root_zip目錄。
            ⑧使用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
  1. #!/usr/bin/env python    
  2. #    
  3. # Copyright (C) 2008 The Android Open Source Project    
  4. #    
  5. # Licensed under the Apache License, Version 2.0 (the "License");    
  6. # you may not use this file except in compliance with the License.    
  7. # You may obtain a copy of the License at    
  8. #    
  9. #      http://www.apache.org/licenses/LICENSE-2.0    
  10. #    
  11. # Unless required by applicable law or agreed to in writing, software    
  12. # distributed under the License is distributed on an "AS IS" BASIS,    
  13. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    
  14. # See the License for the specific language governing permissions and    
  15. # limitations under the License.    
  16.     
  17. """  
  18. Given a target-files zipfile, produces an OTA package that installs  
  19. that build.  An incremental OTA is produced if -i is given, otherwise  
  20. a full OTA is produced.  
  21.   
  22. Usage:  ota_from_target_files [flags] input_target_files output_ota_package  
  23.   
  24.   -b  (--board_config)  <file>  
  25.       Deprecated.  
  26.   
  27.   -k  (--package_key)  <key>  
  28.       Key to use to sign the package (default is  
  29.       "build/target/product/security/testkey").  
  30.   
  31.   -i  (--incremental_from)  <file>  
  32.       Generate an incremental OTA using the given target-files zip as  
  33.       the starting build.  
  34.   
  35.   -w  (--wipe_user_data)  
  36.       Generate an OTA package that will wipe the user data partition  
  37.       when installed.  
  38.   
  39.   -n  (--no_prereq)  
  40.       Omit the timestamp prereq check normally included at the top of  
  41.       the build scripts (used for developer OTA packages which  
  42.       legitimately need to go back and forth).  
  43.   
  44.   -e  (--extra_script)  <file>  
  45.       Insert the contents of file at the end of the update script.  
  46.   
  47. """   

                        下面簡單翻譯一下他們的使用方法以及選項的作用。

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


                       主函數main是python的入口函數，我們從main函數開始看，大概看一下main函數（腳本最後）裏的流程就能知道腳本的執行過程了。

                       ① 在main函數的開頭，首先將用戶設定的option選項存入OPTIONS變量中，它是一個python中的類。緊接着判斷有沒有額外的腳本，如果有就讀入到OPTIONS變量中。
                       ② 解壓縮輸入的zip包，即我們在上文生成的原始zip包。然後判斷是否用到device-specific extensions（設備擴展）如果用到，隨即讀入到OPTIONS變量中。
                       ③ 判斷是否簽名，然後判斷是否有新內容的增量源，有的話就解壓該增量源包放入一個臨時變量中（source_zip）。自此，所有的準備工作已完畢，隨即會調用該 腳本中最主要的函數WriteFullOTAPackage(input_zip,output_zip)
                       ④ WriteFullOTAPackage函數的處理過程是先獲得腳本的生成器。默認格式是edify。然後獲得metadata元數據，此數據來至於Android的一些環境變量。然後獲得設備配置參數比如api函數的版本。然後判斷是否忽略時間戳。
                       ⑤ WriteFullOTAPackage函數做完準備工作後就開始生成升級用的腳本文件(updater-script)了。生成腳本文件後將上一步獲得的metadata元數據寫入到輸出包out_zip。
                       ⑥至此一個完整的update.zip升級包就生成了。生成位置在：out/target/product/tcc8800/full_tcc8800_evm-ota-eng.mumu.20120315.155326.zip。將升級包拷貝到SD卡中就可以用來升級了。
四、 Android OTA增量包update.zip的生成

         在上面的過程中生成的update.zip升級包是全部系統的升級包。大小有80M多。這對手機用戶來說，用來升級的流量是很大的。而且在實際升級中，我們只希望能夠升級我們改變的那部分內容。這就需要使用增量包來升級。生成增量包的過程也需要上文中提到的ota_from_target_files.py的參與。

         下面是製作update.zip增量包的過程。

          ① 在源碼根目錄下依次執行下列命令
           $ . build/envsetup.sh
           $ lunch 選擇17
           $ make
           $ make otapackage
           執行上面的命令後會在out/target/product/tcc8800/下生成我們第一個系統升級包。我們先將其命名爲A.zip
          ② 在源碼中修改我們需要改變的部分，比如修改內核配置，增加新的驅動等等。修改後再一次執行上面的命令。就會生成第二個我們修改後生成的update.zip升級包。將  其命名爲B.zip。

          ③ 在上文中我們看了ota_from_target_files.py腳本的使用幫助，其中選項-i就是用來生成差分增量包的。使用方法是以上面的A.zip 和B.zip包作爲輸入，以update.zip包作  爲輸出。生成的update.zip就是我們最後需要的增量包。

              具體使用方式是：將上述兩個包拷貝到源碼根目錄下，然後執行下面的命令。

              $ ./build/tools/releasetools/ota_from_target_files -i A.zip B.zip update.zip。

              在執行上述命令時會出現未找到recovery_api_version的錯誤。原因是在執行上面的腳本時如果使用選項i則會調用WriteIncrementalOTAPackage會從A包和B包中的META目錄下搜索misc_info.txt來讀取recovery_api_version的值。但是在執行make  otapackage命令時生成的update.zip包中沒有這個目錄更沒有這個文檔。

              此時我們就需要使用執行make otapackage生成的原始的zip包。這個包的位置在out/target/product/tcc8800/obj/PACKAGING/target_files_intermediates/目錄下，它是在用命令make otapackage之後的中間生產物，是最原始的升級包。我們將兩次編譯的生成的包分別重命名爲A.zip和B.zip，並拷貝到SD卡根目錄下重複執行上面的命令：

               $ ./build/tools/releasetools/ota_form_target_files -i A.zip B.zip update.zip。

              在上述命令即將執行完畢時，在device/telechips/common/releasetools.py會調用IncrementalOTA_InstallEnd,在這個函數中讀取包中的RADIO/bootloader.img。

              而包中是沒有這個目錄和bootloader.img的。所以執行失敗，未能生成對應的update.zip。可能與我們未修改bootloader（升級firmware）有關。此問題在下一篇博客已經解決。


             在下一篇中講解制作增量包失敗的原因，以及解決方案。

-------------------------------------------


                      Android系統Recovery工作原理之使用update.zip升級過程分析（二）---update.zip差分包問題的解決

       在上一篇末尾提到的生成差分包時出現的問題，現已解決，由於最近比較忙，相隔的時間也比較長，所以單列一個篇幅提示大家。這個問題居然是源碼中的問題，可能你已經制作成功了，不過我的這個問題確實是源碼中的一個問題，不知道是不是一個bug，下文會具體分析！

一、生成OTA增量包失敗的解決方案

           在上一篇中末尾使用ota_from_target_files腳本製作update.zip增量包時失敗，我們先將出現的錯誤貼出來。

                 

       

              在執行這個腳本的最後讀取input_zip中RADIO/bootloader.img時出現錯誤，顯示DeviceSpecifiParams這個對象中沒有input_zip屬性。

         我們先從腳本中出現錯誤的調用函數中開始查找。出現錯誤的調用地方是在函WriteIncrementalOTAPackage（443行）中的device_specific.IncrementalOTA_InstallEnd()，其位於WriteIncrementalOTAPackage()中的末尾。進一步跟蹤源碼發現，這是一個回調函數，他的具體執行方法位於源碼中/device/telechips/common/releasetools.py腳本中的IncrementalOTA_InstallEnd()函數。下面就分析這個函數的作用。

          releasetools.py腳本中的兩個函數FullOTA_InstallEnd()和IncrementalOTA_InstallEnd()的作用都是從輸入包中讀取RADIO/下的bootloader.img文件寫到輸出包中，同時生成安裝bootloader.img時執行腳本的那部分命令。只不過一個是直接將輸入包中的bootloader.img鏡像寫到輸出包中，一個是先比較target_zip和source_zip中的bootloader.img是否不同（使用選項-i生成差分包時），然後將新的鏡像寫入輸出包中。下面先將這個函數(位於/device/telechips/common/releasetools.py)的具體實現貼出來：

                    

               我們的實際情況是，在用命令make otapackage時生成的包中是沒有這個RADIO目錄下的bootloader.img鏡像文件（因爲這部分更新已被屏蔽掉了）。但是這個函數中對於從包中未讀取到bootloader.img文件的情況是有錯誤處理的，即返回。所以我們要從  出現的實際錯誤中尋找問題的原由。

         真正出現錯誤的地方是：

          target_bootloader=info.input_zip.read(「RADIO/bootloader.img」)。

         出現錯誤的原因是：AttributeError：‘DeviceSpecificParams’object has no attribute  ‘input_zip’，提示我們DeviceSpecificParams對象沒有input_zip這個屬性。

         在用ota_from_target_files腳本製作差分包時使用了選項-i，並且只有這種情況有三個參數，即target_zip 、source_zip、 out_zip。而出現錯誤的地方是target_bootloader=info.input_zip_read(「RADIO/bootloader.img」)，它使用的是input_zip，我們要懷疑這個地方是不是使用錯了，而應該使用info.target_zip.read()。下面可以證實一下我們的猜測。

         從ota_from_target_files腳本中WriteFullOTAPackage()和WriteIncrementalOTAPackage這兩個函數（分別用來生成全包和差分包）可以發現，在他們的開始部分都對device_specific進行了賦值。其中WriteFullOTAPackage()對應的參數是input_zip和out_zip，而WriteIncrementalOTAPackage對應的是target_zip,source_zip,out_zip，我們可以看一下在WriteIncrementalOTAPackage函數中這部分的具體實現：

                  

            從上圖可以發現，在WriteIncrementalOTAPackage函數對DeviceSpecificParams對象進行初始化時確實使用的是target_zip而不是input_zip。而在releasetools.py腳本中使用的卻是info.input_zip.read()，所以纔會出現DeviceSpecificParams對象沒有input_zip這個屬性。由此我們找到了問題的所在(這是不是源碼中的一個Bug？)。

        將releasetools.py腳本IncrementalOTA_InstallEnd(info)函數中的 target_bootloader=info.input_zip.

read(「RADIO/bootloader.img」)爲：target_bootloader=info.target_zip.read(「RADIO/bootloader.img」)，然後重新執行上面提到的製作差分包命令。就生成了我們需要的差分包update.zip。

二、          差分包update.zip的更新測試     

                在上面製作差分包腳本命令中，生成差分包的原理是，參照第一個參數（target_zip），將第二個參數（source_zip）中不同的部分輸出到第三個參數（output_zip）中。其中target_zip與source_zip的先後順序不同，產生的差分包也將不同。

          在實際的測試過程中，我們的增量包要刪除之前添加的一個應用（在使用update.zip全包升級時增加的），其他的部分如內核都沒有改動，所以生成的差分包很簡單，只有META-INF這個文件夾。主要的不同都體現在updater-script腳本中，其中的#----start make changes  here----之後的部分就是做出改變的部分，最主要的腳本命令是： delete(「/system/app/CheckUpdateAll.apk」 , 「/system/recovery.img」);在具體更新時它將刪除CheckUpdateAll.apk這個應用。

          爲了大家參考，還是把這個差分包的升級腳本貼出來，其對應的完全升級的腳本在第九篇已貼出：

[python]  view plain  copy
  1. mount("yaffs2", "MTD", "system", "/system");    
  2. assert(file_getprop("/system/build.prop", "ro.build.fingerprint") == "telechips/full_tcc8800_evm/tcc8800:2.3.5/GRJ90/eng.mumu.20120309.100232:eng/test-keys" ||    
  3.        file_getprop("/system/build.prop", "ro.build.fingerprint") == "telechips/full_tcc8800_evm/tcc8800:2.3.5/GRJ90/eng.mumu.20120309.100232:eng/test-keys");    
  4. assert(getprop("ro.product.device") == "tcc8800" ||    
  5.        getprop("ro.build.product") == "tcc8800");    
  6. ui_print("Verifying current system...");    
  7. show_progress(0.100000, 0);    
  8.     
  9. # ---- start making changes here ----    
  10.     
  11. ui_print("Removing unneeded files...");    
  12. delete("/system/app/CheckUpdateAll.apk",    
  13.        "/system/recovery.img");    
  14. show_progress(0.800000, 0);    
  15. ui_print("Patching system files...");    
  16. show_progress(0.100000, 10);    
  17. ui_print("Symlinks and permissions...");    
  18. set_perm_recursive(0, 0, 0755, 0644, "/system");    
  19. set_perm_recursive(0, 2000, 0755, 0755, "/system/bin");    
  20. set_perm(0, 3003, 02750, "/system/bin/netcfg");    
  21. set_perm(0, 3004, 02755, "/system/bin/ping");    
  22. set_perm(0, 2000, 06750, "/system/bin/run-as");    
  23. set_perm_recursive(1002, 1002, 0755, 0440, "/system/etc/bluetooth");    
  24. set_perm(0, 0, 0755, "/system/etc/bluetooth");    
  25. set_perm(1000, 1000, 0640, "/system/etc/bluetooth/auto_pairing.conf");    
  26. set_perm(3002, 3002, 0444, "/system/etc/bluetooth/blacklist.conf");    
  27. set_perm(1002, 1002, 0440, "/system/etc/dbus.conf");    
  28. set_perm(1014, 2000, 0550, "/system/etc/dhcpcd/dhcpcd-run-hooks");    
  29. set_perm(0, 2000, 0550, "/system/etc/init.goldfish.sh");    
  30. set_perm_recursive(0, 0, 0755, 0555, "/system/etc/ppp");    
  31. set_perm_recursive(0, 2000, 0755, 0755, "/system/xbin");    
  32. set_perm(0, 0, 06755, "/system/xbin/librank");    
  33. set_perm(0, 0, 06755, "/system/xbin/procmem");    
  34. set_perm(0, 0, 06755, "/system/xbin/procrank");    
  35. set_perm(0, 0, 06755, "/system/xbin/su");    
  36. set_perm(0, 0, 06755, "/system/xbin/tcpdump");    
  37. unmount("/system");    

         在做更新測試時，我們要以target_zip系統爲依據，也就是更新之前的開發板系統是用target_zip包升級後的系統。否則會更新就會失敗，因爲在更新時會從系統對應的目錄下讀取設備以及時間戳等信息(updater-script腳本一開始的部分)，進行匹配正確後才進行下一步的安裝。

         所有準備都完成後，將我們製作的差分包放到SD卡中，在Settings-->About Phone-->System Update-->Installed From SDCARD執行更新。最後更新完成並重啓後，我們會發現之前的CheckUpdateAll.apk被成功刪掉了，大功告成！

        至此終於將update.zip包以及其對應的差分包製作成功了，下面的文章開始具體分析製作的update.zip包在實際的更新中所走的過程！

----------------------------------------

            Android系統Recovery工作原理之使用update.zip升級過程分析（三）---Android系統的三種啓動模式

        

        以下的篇幅開始分析我們在上兩個篇幅中生成的update.zip包在具體更新中所經過的過程，並根據源碼分析每一部分的工作原理。

一、       系統更新update.zip包的兩種方式

    1.  通過上一個文檔，我們知道了怎樣製作一個update.zip升級包用於升級系統。Android在升級系統時獲得update.zip包的方式有兩種。一種是離線升級，即手動拷貝升級包到SD卡（或NAND）中，通過settings-->About phone-->System Update-->選擇從SD卡升級。另一種是在線升級，即OTA  Install(over  the  air)。用戶通過在線下載升級包到本地，然後更新。這種方式下的update.zip包一般被下載到系統的/CACHE分區下。

     2.  無論將升級包放在什麼位置，在使用update.zip更新時都會重啓並進入Recovery模式，然後啓動recovery服務（/sbin/recovery）來安裝我們的update.zip包。

    3.  爲此，我們必須瞭解Recovery模式的工作原理以及Android系統重啓時怎樣進入Recovery工作模式而不是其他模式（如正常模式）。

二、       Android系統中三種啓動模式

       首先我們要了解Android系統啓動後可能會進入的幾種工作模式。先看下圖：

                

       由上圖可知Android系統啓動後可能進入的模式有以下幾種：

       (一) MAGIC KEY（組合鍵）：

              即用戶在啓動後通過按下組合鍵，進入不同的工作模式，具體有兩種：             

             ① camera + power：若用戶在啓動剛開始按了camera+power組合鍵則會進入bootloader模式，並可進一步進入fastboot（快速刷機模式）。

        ② home + power ：若用戶在啓動剛開始按了home+power組合鍵，系統會直接進入Recovery模式。以這種方式進入Recovery模式時系統會進入一個簡單的UI（使用了minui）界面，用來提示用戶進一步操作。在tcc8800開發板中提供了一下幾種選項操作：

                                「reboot system now」

                                「apply update from sdcard」

                                「wipe data/factory reset」

                                「wipe cache partition」

       (二)正常啓動：

                 若啓動過程中用戶沒有按下任何組合鍵，bootloader會讀取位於MISC分區的啓動控制信息塊BCB（Bootloader Control Block）。它是一個結構體，存放着啓動命令command。根據不同的命令，系統又 可以進入三種不同的啓動模式。我們先看一下這個結構體的定義。

             struct bootloader_message{

                      char command[32];  //存放不同的啓動命令

                      char status[32];   //update-radio或update-hboot完成存放執行結果

                      char recovery[1024]; //存放/cache/recovery/command中的命令

             };

         我們先看command可能的值，其他的在後文具體分析。command可能的值有兩種，與值爲空（即沒有命令）一起區分三種啓動模式。

         ①command=="boot-recovery"時，系統會進入Recovery模式。Recovery服務會具體根據/cache/recovery/command中的命令執行相應的操作（例如，升級update.zip或擦除cache，data等）。

         ②command=="update-radia"或"update-hboot"時，系統會進入更新firmware（更新bootloader），具體由bootloader完成。

         ③command爲空時，即沒有任何命令，系統會進入正常的啓動，最後進入主系統（main system）。這種是最通常的啓動流程。

         Android系統不同的啓動模式的進入是在不同的情形下觸發的，我們從SD卡中升級我們的update.zip時會進入Recovery模式是其中一種，其他的比如：系統崩潰，或則在命令行輸入啓動命令式也會進入Recovery或其他的啓動模式。

        爲了解我們的update.zip包具體是怎樣在Recovery模式中更新完成，並重啓到主系統的，我們還要分析Android中Recovery模式的工作原理。

     

             下一篇幅開始看具體的Recovery模式工作原理，以及其在更新中的重要作用。

-------------------------------

                             Android系統Recovery模式的工作原理


        在使用update.zip包升級時怎樣從主系統（main system）重啓進入Recovery模式，進入Recovery模式後怎樣判斷做何種操作，以及怎樣獲得主系統發送給Recovery服務的命令，這一系列問題的解決是通過整個軟件平臺的不同部分之間的密切通信配合來完成的。爲此，我們必須要了解Recovery模式的工作原理，這樣才能知道我們的update.zip包是怎樣一步步進入Recovery中升級並最後到達主系統的。

一、Recovery模式中的三個部分

         Recovery的工作需要整個軟件平臺的配合，從通信架構上來看，主要有三個部分。

        ①MainSystem：即上面提到的正常啓動模式（BCB中無命令），是用boot.img啓動的系統，Android的正常工作模式。更新時，在這種模式中我們的上層操作就是使用OTA或則從SD卡中升級update.zip包。在重啓進入Recovery模式之前，會向BCB中寫入命令，以便在重啓後告訴bootloader進入Recovery模式。

        ②Recovery：系統進入Recovery模式後會裝載Recovery分區，該分區包含recovery.img（同boot.img相同，包含了標準的內核和根文件系統）。進入該模式後主要是運行Recovery服務（/sbin/recovery）來做相應的操作（重啓、升級update.zip、擦除cache分區等）。

        ③Bootloader：除了正常的加載啓動系統之外，還會通過讀取MISC分區（BCB）獲得來至Main system和Recovery的消息。

二、Recovery模式中的兩個通信接口

       在Recovery服務中上述的三個實體之間的通信是必不可少的，他們相互之間又有以下兩個通信接口。

       (一)通過CACHE分區中的三個文件：

             Recovery通過/cache/recovery/目錄下的三個文件與mian system通信。具體如下             

            ①/cache/recovery/command：這個文件保存着Main system傳給Recovery的命令行，每一行就是一條命令，支持一下幾種的組合。

                --send_intent=anystring   //write the text out to recovery/intent     在Recovery結束時在finish_recovery函數中將定義的intent字符串作爲參數傳進來，並寫入到/cache/recovery/intent中

                --update_package=root:path   //verify install an OTA package file     Main system將這條命令寫入時,代表系統需要升級，在進入Recovery模式後，將該文件中的命令讀取並寫入BCB中，然後進行相應的更新update.zip包的操作。

                --wipe_data    //erase user data(and cache),then reboot。擦除用戶數據。擦除data分區時必須要擦除cache分區。

                --wipe_cache   //wipe cache(but not user data),then reboot。擦除cache分區。

            ②/cache/recovery/log：Recovery模式在工作中的log打印。在recovery服務運行過程中，stdout以及stderr會重定位到/tmp/recovery.log在recovery退出之前會將其轉存到/cache/recovery/log中，供查看。

            ③/cache/recovery/intent：Recovery傳遞給Main system的信息。作用不詳。

       (二)通過BCB（Bootloader Control Block）：

             BCB是bootloader與Recovery的通信接口，也是Bootloader與Main system之間的通信接口。存儲在flash中的MISC分區，佔用三個page，其本身就是一個結構體，具體成員以及各成員含義如下：

             struct bootloader_message{

                       char command[32];

                       char status[32];

                       char recovery[1024];

              };

            ①command成員：其可能的取值我們在上文已經分析過了，即當我們想要在重啓進入Recovery模式時，會更新這個成員的值。另外在成功更新後結束Recovery時，會清除這個成員的值，防止重啓時再次進入Recovery模式。

            ②status：在完成相應的更新後，Bootloader會將執行結果寫入到這個字段。

            ③recovery：可被Main System寫入，也可被Recovery服務程序寫入。該文件的內容格式爲：

                               「recovery\n

                               <recovery command>\n

                               <recovery command>」

            該文件存儲的就是一個字符串，必須以recovery\n開頭，否則這個字段的所有內容域會被忽略。「recovery\n」之後的部分，是/cache/recovery/command支持的命令。可以將其理解爲Recovery操作過程中對命令操作的備份。Recovery對其操作的過程爲：先讀取BCB然後讀取/cache/recovery/command，然後將二者重新寫回BCB，這樣在進入Main system之前，確保操作被執行。在操作之後進入Main system之前，Recovery又會清空BCB的command域和recovery域，這樣確保重啓後不再進入Recovery模式。

三、如何從Main System重啓並進入Recovery模式

       我們先看一下以上三個部分是怎樣進行通信的，先看下圖：

                       

               我們只看從Main System如何進入Recovery模式，其他的通信在後文中詳述。先從Main System開始看，當我們在Main System使用update.zip包進行升級時，系統會重啓並進入Recovery模式。在系統重啓之前，我們可以看到，Main System定會向BCB中的command域寫入boot-recovery(粉紅色線)，用來告知Bootloader重啓後進入recovery模式。這一步是必須的。至於Main System是否向recovery域寫入值我們在源碼中不能肯定這一點。即便如此，重啓進入Recovery模式後Bootloader會從/cache/recovery/command中讀取值並放入到BCB的recovery域。而Main System在重啓之前肯定會向/cache/recovery/command中寫入Recovery將要進行的操作命令。

         至此，我們就大概知道了，在上層使用update.zip升級時，主系統是怎樣告知重啓後的系統進入Recovery模式的，以及在Recovery模式中完成什麼樣的操作。

         下一篇開始分析第一個階段，即我們在上層使用update.zip包升級時，Main System怎樣重啓並進入Recovery服務的細節流程。

               文章開頭我們就提到update.zip包來源有兩種，一個是OTA在線下載（一般下載到/CACHE分區），一個是手動拷貝到SD卡中。不論是哪種方式獲得update.zip包，在進入Recovery模式前，都未對這個zip包做處理。只是在重啓之前將zip包的路徑告訴了Recovery服務（通過將--update_package=CACHE:some_filename.zip或--update_package=SDCARD:update.zip命令寫入到/cache/recovery/command中）。在這裏我們假設update.zip包已經制作好並拷貝到了SD卡中，並以Settings-->About Phone-->System Update-->Installed From SDCARD方式升級。

         我們的測試開發板是TCC8800，使用的Android源碼是gingerbread0919，在這種方式下升級的源碼位於gingerbread/device/telechips/common/apps/TelechipsSystemUpdater/src/com/telechips/android/systemupdater/下。         下面我們具體分析這種升級方式下，我們的update.zip是怎樣從上層一步步進入到Recovery模式的。


一、從System Update到Reboot


        當我們依次選擇Settings-->About Phone-->System Update-->Installed From SDCARD後會彈出一個對話框，提示已有update.zip包是否現在更新，我們從這個地方跟蹤。這個對話框的源碼是SystemUpdateInstallDialog.java。


        ①在mNowButton按鈕的監聽事件裏，會調用mService.rebootAndUpdate（new  File(mFile)）。這個mService就是SystemUpdateService的實例。 這  個類所在的源碼文件是SystemUpdateService.java。這個函數的參數是一個文件。它肯定就是我們的update.zip包了。我們可以證實一下這個猜想。

        ②mFile的值：在SystemUpdateInstallDialog.java中的ServiceConnection中我們可以看到這個mFile的值有兩個來源。

                 來源一：

                  mFile的一個來源是這個是否立即更新提示框接受的上一個Activity以「file」標記傳來的值。這個Activity就是SystemUpdate.java。它是一個PreferenceActivity類型的。在其onPreferenceChange函數中定義了向下一個Activity傳送的值，這個值是根據我們不同的選擇而定的。如果我們在之前選擇了從SD卡安裝，則這個傳下去的「file」值爲「/sdcard/update.zip」。如果選擇了從NAND安裝，則對應的值爲「/nand/update.zip」。


                 來源二：

                 另個一來源是從mService.getInstallFile()獲得。我們進一步跟蹤就可發現上面這個函數獲得的值就是「/cache」+ mUpdateFileURL.getFile();這就是OTA在線下載後對應的文件路徑。不論參數mFile的來源如何，我們可以發現在mNowButton按鈕的監聽事件裏是將整個文件，也就是我們的update.zip包作爲參數往rebootAndUpdate（）中傳遞的。

        ③rebootAndUpdate:在這個函數中Main System做了重啓前的準備。繼續跟蹤下去會發現，在SystemUpdateService.java中的rebootAndUpdate函數中新建了一個線程，在這個線程中最後調用的就是RecoverySystem.installPackage(mContext,mFile)，我們的update.zip包也被傳遞進來了。

        ④RecoverySystem類：RecoverySystem類的源碼所在文件路徑爲：gingerbread0919/frameworks/base/core/java/android/os/RecoverySystem.java。我們關心的是installPackage(Context context,FilepackageFile)函數。這個函數首先根據我們傳過來的包文件，獲取這個包文件的絕對路徑filename。然後將其拼成arg=「--update_package=」+filename。它最終會被寫入到BCB中。這個就是重啓進入Recovery模式後，Recovery服務要進行的操作。它被傳遞到函數bootCommand(context,arg)。

        ⑤bootCommand()：在這個函數中才是Main System在重啓前真正做的準備。主要做了以下事情，首先創建/cache/recovery/目錄，刪除這個目錄下的command和log（可能不存在）文件在sqlite數據庫中的備份。然後將上面④步中的arg命令寫入到/cache/recovery/command文件中。下一步就是真正重啓了。接下來看一下在重啓函數reboot中所做的事情。

         ⑥pm.reboot()：重啓之前先獲得了PowerManager（電源管理）並進一步獲得其系統服務。然後調用了pm.reboot(「recovery」)函數。他就是/gingerbread0919/bionic/libc/unistd/reboot.c中的reboot函數。這個函數實際上是一個系統調用，即__reboot(LINUX_REBOOT_MAGIC1,LINUX_REBOOT_MAGIC2,mode,NULL);從這個函數我們可以看出前兩個參數就代表了我們的組合鍵，mode就是我們傳過來的「recovery」。再進一步跟蹤就到了彙編代碼了，我們無法直接查看它的具體實現細節。但可以肯定的是 這個函數只將「recovery」參數傳遞過去了，之後將「boot-recovery」寫入到了MISC分區的BCB數據塊的command域中。這樣在重啓之後Bootloader才知道要進入Recovery模式。


         在這裏我們無法肯定Main System在重啓之前對BCB的recovery域是否進行了操作。其實在重啓前是否更新BCB的recovery域是不重要的，因爲進入Recovery服務後，Recovery會自動去/cache/recovery/command中讀取要進行的操作然後寫入到BCB的recovery域中。

         至此，Main System就開始重啓並進入Recovery模式。在這之前Main System做的最實質的就是兩件事，一是將「boot-recovery」寫入BCB的command域，二是將--update_package=/cache/update.zip」或則「--update_package=/sdcard/update.zip」寫入/cache/recovery/command文件中。下面的部分就開始重啓並進入Recovery服務了。

二、從reboot到Recovery服務

       

            這個過程我們在上文（對照第一個圖）已經講過了。從Bootloader開始如果沒有組合鍵按下，就從MISC分區讀取BCB塊的command域（在主系統時已經將「boot-recovery」寫入）。然後就以Recovery模式開始啓動。與正常啓動不同的是Recovery模式下加載的鏡像是recovery.img。這個鏡像同boot.img類似，也包含了標準的內核和根文件系統。其後就與正常的啓動系統類似，也是啓動內核，然後啓動文件系統。在進入文件系統後會執行/init，init的配置文件就是/init.rc。這個配置文件來自bootable/recovery/etc/init.rc。查看這個文件我們可以看到它做的事情很簡單：

       ①設置環境變量。

       ②建立etc連接。

       ③新建目錄，備用。

       ④掛載/tmp爲內存文件系統tmpfs

       ⑤啓動recovery（/sbin/recovery）服務。

       ⑥啓動adbd服務(用於調試)。

       這裏最重要的就是當然就recovery服務了。在Recovery服務中將要完成我們的升級工作。

       我們將在下一篇詳細分析Recovery服務的流程細節。



         Recovery服務毫無疑問是Recovery啓動模式中最核心的部分。它完成Recovery模式所有的工作。Recovery程序對應的源碼文件位於：/gingerbread0919/bootable/recovery/recovery.c。


一、 Recovery的三類服務：

         先看一下在這個源碼文件中開始部分的一大段註釋，這將對我們理解Recovery服務的主要功能有很大幫助。代碼如下：

         

[cpp]  view plain  copy
  1. /*  
  2.  * The recovery tool communicates with the main system through /cache files.  
  3.  *   /cache/recovery/command - INPUT - command line for tool, one arg per line  
  4.  *   /cache/recovery/log - OUTPUT - combined log file from recovery run(s)  
  5.  *   /cache/recovery/intent - OUTPUT - intent that was passed in  
  6.  *  
  7.  * The arguments which may be supplied in the recovery.command file:  
  8.  *   --send_intent=anystring - write the text out to recovery.intent  
  9.  *   --update_package=path - verify install an OTA package file  
  10.  *   --wipe_data - erase user data (and cache), then reboot  
  11.  *   --wipe_cache - wipe cache (but not user data), then reboot  
  12.  *   --set_encrypted_filesystem=on|off - enables / diasables encrypted fs  
  13.  *  
  14.  * After completing, we remove /cache/recovery/command and reboot.  
  15.  * Arguments may also be supplied in the bootloader control block (BCB).  
  16.  * These important scenarios must be safely restartable at any point:  
  17.  *  
  18.  * FACTORY RESET  
  19.  * 1. user selects "factory reset"  
  20.  * 2. main system writes "--wipe_data" to /cache/recovery/command  
  21.  * 3. main system reboots into recovery  
  22.  * 4. get_args() writes BCB with "boot-recovery" and "--wipe_data"  
  23.  *    -- after this, rebooting will restart the erase --  
  24.  * 5. erase_volume() reformats /data  
  25.  * 6. erase_volume() reformats /cache  
  26.  * 7. finish_recovery() erases BCB  
  27.  *    -- after this, rebooting will restart the main system --  
  28.  * 8. main() calls reboot() to boot main system  
  29.  *  
  30.  * OTA INSTALL  
  31.  * 1. main system downloads OTA package to /cache/some-filename.zip  
  32.  * 2. main system writes "--update_package=/cache/some-filename.zip"  
  33.  * 3. main system reboots into recovery  
  34.  * 4. get_args() writes BCB with "boot-recovery" and "--update_package=..."  
  35.  *    -- after this, rebooting will attempt to reinstall the update --  
  36.  * 5. install_package() attempts to install the update  
  37.  *    NOTE: the package install must itself be restartable from any point  
  38.  * 6. finish_recovery() erases BCB  
  39.  *    -- after this, rebooting will (try to) restart the main system --  
  40.  * 7. ** if install failed **  
  41.  *    7a. prompt_and_wait() shows an error icon and waits for the user  
  42.  *    7b; the user reboots (pulling the battery, etc) into the main system  
  43.  * 8. main() calls maybe_install_firmware_update()  
  44.  *    ** if the update contained radio/hboot firmware **:  
  45.  *    8a. m_i_f_u() writes BCB with "boot-recovery" and "--wipe_cache"  
  46.  *        -- after this, rebooting will reformat cache & restart main system --  
  47.  *    8b. m_i_f_u() writes firmware image into raw cache partition  
  48.  *    8c. m_i_f_u() writes BCB with "update-radio/hboot" and "--wipe_cache"  
  49.  *        -- after this, rebooting will attempt to reinstall firmware --  
  50.  *    8d. bootloader tries to flash firmware  
  51.  *    8e. bootloader writes BCB with "boot-recovery" (keeping "--wipe_cache")  
  52.  *        -- after this, rebooting will reformat cache & restart main system --  
  53.  *    8f. erase_volume() reformats /cache  
  54.  *    8g. finish_recovery() erases BCB  
  55.  *        -- after this, rebooting will (try to) restart the main system --  
  56.  * 9. main() calls reboot() to boot main system  
  57.  *  
  58.  * SECURE FILE SYSTEMS ENABLE/DISABLE  
  59.  * 1. user selects "enable encrypted file systems"  
  60.  * 2. main system writes "--set_encrypted_filesystems=on|off" to  
  61.  *    /cache/recovery/command  
  62.  * 3. main system reboots into recovery  
  63.  * 4. get_args() writes BCB with "boot-recovery" and  
  64.  *    "--set_encrypted_filesystems=on|off"  
  65.  *    -- after this, rebooting will restart the transition --  
  66.  * 5. read_encrypted_fs_info() retrieves encrypted file systems settings from /data  
  67.  *    Settings include: property to specify the Encrypted FS istatus and  
  68.  *    FS encryption key if enabled (not yet implemented)  
  69.  * 6. erase_volume() reformats /data  
  70.  * 7. erase_volume() reformats /cache  
  71.  * 8. restore_encrypted_fs_info() writes required encrypted file systems settings to /data  
  72.  *    Settings include: property to specify the Encrypted FS status and  
  73.  *    FS encryption key if enabled (not yet implemented)  
  74.  * 9. finish_recovery() erases BCB  
  75.  *    -- after this, rebooting will restart the main system --  
  76.  * 10. main() calls reboot() to boot main system  
  77.  */    

          從註釋中我們可以看到Recovery的服務內容主要有三類：

         ①FACTORY RESET，恢復出廠設置。

         ②OTA INSTALL，即我們的update.zip包升級。

         ③ENCRYPTED FILE SYSTEM ENABLE/DISABLE，使能/關閉加密文件系統。具體的每一類服務的大概工作流程，註釋中都有，我們在下文中會詳細講解OTA INSTALL的工作流程。這三類服務的大概的流程都是通用的，只是不同操作體現與不同的操作細節。下面我們看Recovery服務的通用流程。

二、Recovery服務的通用流程：

        在這裏我們以OTA INSTALL的流程爲例具體分析。並從相關函數的調用過程圖開始，如下圖:


          

          我們順着流程圖分析，從recovery.c的main函數開始：

          1.    ui_init()：Recovery服務使用了一個基於framebuffer的簡單ui（miniui）系統。這個函數對其進行了簡單的初始化。在Recovery服務的過程中主要用於顯示一個背景圖片（正在安裝或安裝失敗）和一個進度條（用於顯示進度）。另外還啓動了兩個線程，一個用於處理進度條的顯示（progress_thread），另一個用於響應用戶的按鍵（input_thread）。

          2.    get_arg()：這個函數主要做了上圖中get_arg()往右往下直到parse arg/v的工作。我們對照着流程一個一個看。

                ①get_bootloader_message()：主要工作是根據分區的文件格式類型（mtd或emmc）從MISC分區中讀取BCB數據塊到一個臨時的變量中。

                ②然後開始判斷Recovery服務是否有帶命令行的參數（/sbin/recovery，根據現有的邏輯是沒有的），若沒有就從BCB中讀取recovery域。如果讀取失敗則從/cache/recovery/command中讀取然後。這樣這個BCB的臨時變量中的recovery域就被更新了。在將這個BCB的臨時變量寫回真實的BCB之前，又更新的這個BCB臨時變量的command域爲「boot-recovery」。這樣做的目的是如果在升級失敗（比如升級還未結束就斷電了）時，系統在重啓之後還會進入Recovery模式，直到升級完成。

                ③在這個BCB臨時變量的各個域都更新完成後使用set_bootloader_message()寫回到真正的BCB塊中。

                這個過程可以用一個簡單的圖來概括，這樣更清晰：

                                 


          3.     parserargc/argv：解析我們獲得參數。註冊所解析的命令（register_update_command），在下面的操作中會根據這一步解析的值進行一步步的判斷，然後進行相應的操作。

          4.    if(update_package)：判斷update_package是否有值，若有就表示需要升級更新包，此時就會調用install_package()（即圖中紅色的第二個階段）。在這一步中將要完成安裝實際的升級包。這是最爲複雜，也是升級update.zip包最爲核心的部分。我們在下一節詳細分析這一過程。爲從宏觀上理解Recovery服務的框架，我們將這一步先略過，假設已經安裝完成了。我們接着往下走，看安裝完成後Recovery怎樣一步步結束服務，並重啓到新的主系統的。

          5.    if(wipe_data/wipe_cache)：這一步判斷實際是兩步，在源碼中是先判斷是否擦除data分區（用戶數據部分）的，然後再判斷是否擦除cache分區。值得注意的是在擦除data分區的時候必須連帶擦除cache分區。在只擦除cache分區的情形下可以不擦除data分區。

          6.    maybe_install_firmware_update()：如果升級包中包含/radio/hboot firmware的更新，則會調用這個函數。查看源碼發現，在註釋中（OTA INSTALL）有這一個流程。但是main函數中並沒有顯示調用這個函數。目前尚未發現到底是在什麼地方處理。但是其流程還是向上面的圖示一樣。即，① 先向BCB中寫入「boot-recovery」和「—wipe_cache」之後將cache分區格式化，然後將firmware image 寫入原始的cache分區中。②將命令「update-radio/hboot」和「—wipe_cache」寫入BCB中，然後開始重新安裝firmware並刷新firmware。③之後又會進入圖示中的末尾，即finish_recovery()。

          7.    prompt_and_wait()：這個函數是在一個判斷中被調用的。其意義是如果安裝失敗（update.zip包錯誤或驗證簽名失敗），則等待用戶的輸入處理（如通過組合鍵reboot等）。

          8.    finish_recovery()：這是Recovery關閉並進入Main System的必經之路。其大體流程如下：

                                               

               ① 將intent（字符串）的內容作爲參數傳進finish_recovery中。如果有intent需要告知Main System，則將其寫入/cache/recovery/intent中。這個intent的作用尚不知有何用。

               ② 將內存文件系統中的Recovery服務的日誌（/tmp/recovery.log）拷貝到cache（/cache/recovery/log）分區中，以便告知重啓後的Main System發生過什麼。

               ③ 擦除MISC分區中的BCB數據塊的內容，以便系統重啓後不在進入Recovery模式而是進入更新後的主系統。

               ④ 刪除/cache/recovery/command文件。這一步也是很重要的，因爲重啓後Bootloader會自動檢索這個文件，如果未刪除的話又會進入Recovery模式。原理在上面已經講的很清楚了。


          9.    reboot()：這是一個系統調用。在這一步Recovery完成其服務重啓並進入Main System。這次重啓和在主系統中重啓進入Recovery模式調用的函數是一樣的，但是其方向是不一樣的。所以參數也就不一樣。查看源碼發現，其重啓模式是RB_AUTOBOOT。這是一個系統的宏。

 

            至此，我們對Recovery服務的整個流程框架已有了大概的認識。下面就是升級update.zip包時特有的也是Recovery服務中關於安裝升級包最核心的第二個階段。即我們圖例中的紅色2的那個分支。


           我們將在下一篇詳細講解這一部分，即Recovery服務的核心部分install_package函數



一、       Recovery服務的核心install_package（升級update.zip特有）


              和Recovery服務中的wipe_data、wipe_cache不同，install_package()是升級update.zip特有的一部分，也是最核心的部分。在這一步才真正開始對我們的update.zip包進行處理。下面就開始分析這一部分。還是先看圖例：

                          

            這一部分的源碼文件位於：/gingerbread0919/bootable/recovery/install.c。這是一個沒有main函數的源碼文件，還是把源碼先貼出來如下：

[cpp]  view plain  copy
  1. /*  
  2.  * Copyright (C) 2007 The Android Open Source Project  
  3.  *  
  4.  * Licensed under the Apache License, Version 2.0 (the "License");  
  5.  * you may not use this file except in compliance with the License.  
  6.  * You may obtain a copy of the License at  
  7.  *  
  8.  *      http://www.apache.org/licenses/LICENSE-2.0  
  9.  *  
  10.  * Unless required by applicable law or agreed to in writing, software  
  11.  * distributed under the License is distributed on an "AS IS" BASIS,  
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
  13.  * See the License for the specific language governing permissions and  
  14.  * limitations under the License.  
  15.  */    
  16.     
  17. #include <ctype.h>    
  18. #include <errno.h>    
  19. #include <fcntl.h>    
  20. #include <limits.h>    
  21. #include <sys/stat.h>    
  22. #include <sys/wait.h>    
  23. #include <unistd.h>    
  24.     
  25. #include "common.h"    
  26. #include "install.h"    
  27. #include "mincrypt/rsa.h"    
  28. #include "minui/minui.h"    
  29. #include "minzip/SysUtil.h"    
  30. #include "minzip/Zip.h"    
  31. #include "mtdutils/mounts.h"    
  32. #include "mtdutils/mtdutils.h"    
  33. #include "roots.h"    
  34. #include "verifier.h"    
  35.     
  36. #define ASSUMED_UPDATE_BINARY_NAME  "META-INF/com/google/android/update-binary"    
  37. #define PUBLIC_KEYS_FILE "/res/keys"    
  38.     
  39. // If the package contains an update binary, extract it and run it.    
  40. static int    
  41. try_update_binary(const char *path, ZipArchive *zip) {    
  42.     const ZipEntry* binary_entry =    
  43.             mzFindZipEntry(zip, ASSUMED_UPDATE_BINARY_NAME);    
  44.     if (binary_entry == NULL) {    
  45.         mzCloseZipArchive(zip);    
  46.         return INSTALL_CORRUPT;    
  47.     }    
  48.     
  49.     char* binary = "/tmp/update_binary";    
  50.     unlink(binary);    
  51.     int fd = creat(binary, 0755);    
  52.     if (fd < 0) {    
  53.         mzCloseZipArchive(zip);    
  54.         LOGE("Can't make %s\n", binary);    
  55.         return 1;    
  56.     }    
  57.     bool ok = mzExtractZipEntryToFile(zip, binary_entry, fd);    
  58.     close(fd);    
  59.     mzCloseZipArchive(zip);    
  60.     
  61.     if (!ok) {    
  62.         LOGE("Can't copy %s\n", ASSUMED_UPDATE_BINARY_NAME);    
  63.         return 1;    
  64.     }    
  65.     
  66.     int pipefd[2];    
  67.     pipe(pipefd);    
  68.     
  69.     // When executing the update binary contained in the package, the    
  70.     // arguments passed are:    
  71.     //    
  72.     //   - the version number for this interface    
  73.     //    
  74.     //   - an fd to which the program can write in order to update the    
  75.     //     progress bar.  The program can write single-line commands:    
  76.     //    
  77.     //        progress <frac> <secs>    
  78.     //            fill up the next <frac> part of of the progress bar    
  79.     //            over <secs> seconds.  If <secs> is zero, use    
  80.     //            set_progress commands to manually control the    
  81.     //            progress of this segment of the bar    
  82.     //    
  83.     //        set_progress <frac>    
  84.     //            <frac> should be between 0.0 and 1.0; sets the    
  85.     //            progress bar within the segment defined by the most    
  86.     //            recent progress command.    
  87.     //    
  88.     //        firmware <"hboot"|"radio"> <filename>    
  89.     //            arrange to install the contents of <filename> in the    
  90.     //            given partition on reboot.    
  91.     //    
  92.     //            (API v2: <filename> may start with "PACKAGE:" to    
  93.     //            indicate taking a file from the OTA package.)    
  94.     //    
  95.     //            (API v3: this command no longer exists.)    
  96.     //    
  97.     //        ui_print <string>    
  98.     //            display <string> on the screen.    
  99.     //    
  100.     //   - the name of the package zip file.    
  101.     //    
  102.     
  103.     char** args = malloc(sizeof(char*) * 5);    
  104.     args[0] = binary;    
  105.     args[1] = EXPAND(RECOVERY_API_VERSION);   // defined in Android.mk    
  106.     args[2] = malloc(10);    
  107.     sprintf(args[2], "%d", pipefd[1]);    
  108.     args[3] = (char*)path;    
  109.     args[4] = NULL;    
  110.     
  111.     pid_t pid = fork();    
  112.     if (pid == 0) {    
  113.         close(pipefd[0]);    
  114.         execv(binary, args);    
  115.         fprintf(stdout, "E:Can't run %s (%s)\n", binary, strerror(errno));    
  116.         _exit(-1);    
  117.     }    
  118.     close(pipefd[1]);    
  119.     
  120.     char buffer[1024];    
  121.     FILE* from_child = fdopen(pipefd[0], "r");    
  122.     while (fgets(buffer, sizeof(buffer), from_child) != NULL) {    
  123.         char* command = strtok(buffer, " \n");    
  124.         if (command == NULL) {    
  125.             continue;    
  126.         } else if (strcmp(command, "progress") == 0) {    
  127.             char* fraction_s = strtok(NULL, " \n");    
  128.             char* seconds_s = strtok(NULL, " \n");    
  129.     
  130.             float fraction = strtof(fraction_s, NULL);    
  131.             int seconds = strtol(seconds_s, NULL, 10);    
  132.     
  133.             ui_show_progress(fraction * (1-VERIFICATION_PROGRESS_FRACTION),    
  134.                              seconds);    
  135.         } else if (strcmp(command, "set_progress") == 0) {    
  136.             char* fraction_s = strtok(NULL, " \n");    
  137.             float fraction = strtof(fraction_s, NULL);    
  138.             ui_set_progress(fraction);    
  139.         } else if (strcmp(command, "ui_print") == 0) {    
  140.             char* str = strtok(NULL, "\n");    
  141.             if (str) {    
  142.                 ui_print("%s", str);    
  143.             } else {    
  144.                 ui_print("\n");    
  145.             }    
  146.         } else {    
  147.             LOGE("unknown command [%s]\n", command);    
  148.         }    
  149.     }    
  150.     fclose(from_child);    
  151.     
  152.     int status;    
  153.     waitpid(pid, &status, 0);    
  154.     if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {    
  155.         LOGE("Error in %s\n(Status %d)\n", path, WEXITSTATUS(status));    
  156.         return INSTALL_ERROR;    
  157.     }    
  158.     
  159.     return INSTALL_SUCCESS;    
  160. }    
  161.     
  162. // Reads a file containing one or more public keys as produced by    
  163. // DumpPublicKey:  this is an RSAPublicKey struct as it would appear    
  164. // as a C source literal, eg:    
  165. //    
  166. //  "{64,0xc926ad21,{1795090719,...,-695002876},{-857949815,...,1175080310}}"    
  167. //    
  168. // (Note that the braces and commas in this example are actual    
  169. // characters the parser expects to find in the file; the ellipses    
  170. // indicate more numbers omitted from this example.)    
  171. //    
  172. // The file may contain multiple keys in this format, separated by    
  173. // commas.  The last key must not be followed by a comma.    
  174. //    
  175. // Returns NULL if the file failed to parse, or if it contain zero keys.    
  176. static RSAPublicKey*    
  177. load_keys(const char* filename, int* numKeys) {    
  178.     RSAPublicKey* out = NULL;    
  179.     *numKeys = 0;    
  180.     
  181.     FILE* f = fopen(filename, "r");    
  182.     if (f == NULL) {    
  183.         LOGE("opening %s: %s\n", filename, strerror(errno));    
  184.         goto exit;    
  185.     }    
  186.     
  187.     int i;    
  188.     bool done = false;    
  189.     while (!done) {    
  190.         ++*numKeys;    
  191.         out = realloc(out, *numKeys * sizeof(RSAPublicKey));    
  192.         RSAPublicKey* key = out + (*numKeys - 1);    
  193.         if (fscanf(f, " { %i , 0x%x , { %u",    
  194.                    &(key->len), &(key->n0inv), &(key->n[0])) != 3) {    
  195.             goto exit;    
  196.         }    
  197.         if (key->len != RSANUMWORDS) {    
  198.             LOGE("key length (%d) does not match expected size\n", key->len);    
  199.             goto exit;    
  200.         }    
  201.         for (i = 1; i < key->len; ++i) {    
  202.             if (fscanf(f, " , %u", &(key->n[i])) != 1) goto exit;    
  203.         }    
  204.         if (fscanf(f, " } , { %u", &(key->rr[0])) != 1) goto exit;    
  205.         for (i = 1; i < key->len; ++i) {    
  206.             if (fscanf(f, " , %u", &(key->rr[i])) != 1) goto exit;    
  207.         }    
  208.         fscanf(f, " } } ");    
  209.     
  210.         // if the line ends in a comma, this file has more keys.    
  211.         switch (fgetc(f)) {    
  212.             case ',':    
  213.                 // more keys to come.    
  214.                 break;    
  215.     
  216.             case EOF:    
  217.                 done = true;    
  218.                 break;    
  219.     
  220.             default:    
  221.                 LOGE("unexpected character between keys\n");    
  222.                 goto exit;    
  223.         }    
  224.     }    
  225.     
  226.     fclose(f);    
  227.     return out;    
  228.     
  229. exit:    
  230.     if (f) fclose(f);    
  231.     free(out);    
  232.     *numKeys = 0;    
  233.     return NULL;    
  234. }    
  235.     
  236. int    
  237. install_package(const char *path)    
  238. {    
  239.     ui_set_background(BACKGROUND_ICON_INSTALLING);    
  240.     ui_print("Finding update package...\n");    
  241.     ui_show_indeterminate_progress();    
  242.     LOGI("Update location: %s\n", path);    
  243.     
  244.     if (ensure_path_mounted(path) != 0) {    
  245.         LOGE("Can't mount %s\n", path);    
  246.         return INSTALL_CORRUPT;    
  247.     }    
  248.     
  249.     ui_print("Opening update package...\n");    
  250.     
  251.     int numKeys;    
  252.     RSAPublicKey* loadedKeys = load_keys(PUBLIC_KEYS_FILE, &numKeys);    
  253.     if (loadedKeys == NULL) {    
  254.         LOGE("Failed to load keys\n");    
  255.         return INSTALL_CORRUPT;    
  256.     }    
  257.     LOGI("%d key(s) loaded from %s\n", numKeys, PUBLIC_KEYS_FILE);    
  258.     
  259.     // Give verification half the progress bar...    
  260.     ui_print("Verifying update package...\n");    
  261.     ui_show_progress(    
  262.             VERIFICATION_PROGRESS_FRACTION,    
  263.             VERIFICATION_PROGRESS_TIME);    
  264.     
  265.     int err;    
  266.     err = verify_file(path, loadedKeys, numKeys);    
  267.     free(loadedKeys);    
  268.     LOGI("verify_file returned %d\n", err);    
  269.     if (err != VERIFY_SUCCESS) {    
  270.         LOGE("signature verification failed\n");    
  271.         return INSTALL_CORRUPT;    
  272.     }    
  273.     
  274.     /* Try to open the package.  
  275.      */    
  276.     ZipArchive zip;    
  277.     err = mzOpenZipArchive(path, &zip);    
  278.     if (err != 0) {    
  279.         LOGE("Can't open %s\n(%s)\n", path, err != -1 ? strerror(err) : "bad");    
  280.         return INSTALL_CORRUPT;    
  281.     }    
  282.     
  283.     /* Verify and install the contents of the package.  
  284.      */    
  285.     ui_print("Installing update...\n");    
  286.     return try_update_binary(path, &zip);    
  287. }    
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程