auto import from //branches/cupcake/...@126645

34 files changed, 1849 insertions, 119 deletions

diff --git a/buildspec.mk.default b/buildspec.mk.default
index e4ec713..bf4d111 100644
--- a/buildspec.mk.default
+++ b/buildspec.mk.default
@@ -16,7 +16,7 @@
 
 ######################################################################
 # This is a do-nothing template file.  To use it, copy it to a file
-# named "buildspec.mk" in the same directory, and uncomment or change
+# named "buildspec.mk" in the root directory, and uncomment or change
 # the variables necessary for your desired configuration.  The file
 # "buildspec.mk" should never be checked in to source control.
 ######################################################################
diff --git a/cleanspec.mk b/cleanspec.mk
index 92c0a56..f7a215b 100644
--- a/cleanspec.mk
+++ b/cleanspec.mk
@@ -55,6 +55,10 @@ INTERNAL_CLEAN_BUILD_VERSION := 2
 #$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
 #$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
 
+$(call add-clean-step, rm -f $(PRODUCT_OUT)/system/etc/NOTICE.html)
+# Remove generated java files after CL 126153
+$(call add-clean-step, find $(OUT_DIR) -type f -name "*.java" -print0 | xargs -0 rm -f)
+
 # ************************************************
 # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
 # ************************************************
diff --git a/core/Makefile b/core/Makefile
index 84fa2e2..0d82299 100644
--- a/core/Makefile
+++ b/core/Makefile
@@ -112,6 +112,7 @@ $(INSTALLED_BUILD_PROP_TARGET): $(BUILDINFO_SH) $(INTERNAL_BUILD_ID_MAKEFILE)
 			BUILD_VERSION_TAGS="$(BUILD_VERSION_TAGS)" \
 			TARGET_BOOTLOADER_BOARD_NAME="$(TARGET_BOOTLOADER_BOARD_NAME)" \
 			BUILD_FINGERPRINT="$(BUILD_FINGERPRINT)" \
+			TARGET_BOARD_PLATFORM="$(TARGET_BOARD_PLATFORM)" \
 	        bash $(BUILDINFO_SH) > $@
 	$(hide) if [ -f $(TARGET_DEVICE_DIR)/system.prop ]; then \
 	          cat $(TARGET_DEVICE_DIR)/system.prop >> $@; \
@@ -399,6 +400,7 @@ endef
 
 target_notice_file_txt := $(TARGET_OUT_INTERMEDIATES)/NOTICE.txt
 target_notice_file_html := $(TARGET_OUT_INTERMEDIATES)/NOTICE.html
+target_notice_file_html_gz := $(TARGET_OUT_INTERMEDIATES)/NOTICE.html.gz
 tools_notice_file_txt := $(HOST_OUT_INTERMEDIATES)/NOTICE.txt
 tools_notice_file_html := $(HOST_OUT_INTERMEDIATES)/NOTICE.html
 
@@ -418,15 +420,17 @@ $(eval $(call combine-notice-files, \
 			$(HOST_OUT_NOTICE_FILES), \
 			$(ALL_DEFAULT_INSTALLED_MODULES)))
 
-# Install the html file at /system/NOTICE.html.
+# Install the html file at /system/etc/NOTICE.html.gz.
 # This is not ideal, but this is very late in the game, after a lot of
 # the module processing has already been done -- in fact, we used the
 # fact that all that has been done to get the list of modules that we
 # need notice files for.
-installed_notice_html := $(TARGET_OUT)/etc/NOTICE.html
-$(installed_notice_html): $(target_notice_file_html) | $(ACP)
+$(target_notice_file_html_gz): $(target_notice_file_html)
+	gzip -c $< > $@
+installed_notice_html_gz := $(TARGET_OUT)/etc/NOTICE.html.gz
+$(installed_notice_html_gz): $(target_notice_file_html_gz) | $(ACP)
 	$(copy-file-to-target)
-ALL_DEFAULT_INSTALLED_MODULES += $(installed_notice_html)
+ALL_DEFAULT_INSTALLED_MODULES += $(installed_notice_html_gz)
 
 # The kernel isn't really a module, so to get its module file in there, we
 # make the target NOTICE files depend on this particular file too, which will
diff --git a/core/base_rules.mk b/core/base_rules.mk
index 2c442f6..ba89c40 100644
--- a/core/base_rules.mk
+++ b/core/base_rules.mk
@@ -57,8 +57,8 @@ endif
 
 LOCAL_MODULE_TAGS := $(sort $(LOCAL_MODULE_TAGS))
 ifeq (,$(LOCAL_MODULE_TAGS))
-# Modules without tags fall back to the default set
-LOCAL_MODULE_TAGS := eng user development
+# Modules without tags fall back to user (which is changed to user eng below)
+LOCAL_MODULE_TAGS := user
 #$(warning default tags: $(lastword $(filter-out config/% out/%,$(MAKEFILE_LIST))))
 endif
 
diff --git a/core/clear_vars.mk b/core/clear_vars.mk
index 768a0ac..f090507 100644
--- a/core/clear_vars.mk
+++ b/core/clear_vars.mk
@@ -81,6 +81,8 @@ LOCAL_ALLOW_UNDEFINED_SYMBOLS:=
 LOCAL_DX_FLAGS:=
 LOCAL_CERTIFICATE:=
 LOCAL_SDK_VERSION:=
+LOCAL_NO_EMMA_INSTRUMENT:=
+LOCAL_NO_EMMA_COMPILE:=
 
 # Trim MAKEFILE_LIST so that $(call my-dir) doesn't need to
 # iterate over thousands of entries every time.
diff --git a/core/config.mk b/core/config.mk
index 81063b5..90e5362 100644
--- a/core/config.mk
+++ b/core/config.mk
@@ -16,6 +16,7 @@ SRC_DOCS:= $(TOPDIR)docs
 SRC_HEADERS := \
 	$(TOPDIR)system/core/include \
 	$(TOPDIR)hardware/libhardware/include \
+	$(TOPDIR)hardware/libhardware_legacy/include \
 	$(TOPDIR)hardware/ril/include \
 	$(TOPDIR)dalvik/libnativehelper/include \
 	$(TOPDIR)frameworks/base/include \
@@ -171,6 +172,7 @@ KCM := $(HOST_OUT_EXECUTABLES)/kcm$(HOST_EXECUTABLE_SUFFIX)
 ZIPALIGN := $(HOST_OUT_EXECUTABLES)/zipalign$(HOST_EXECUTABLE_SUFFIX)
 FINDBUGS := prebuilt/common/findbugs/bin/findbugs
 LOCALIZE := $(HOST_OUT_EXECUTABLES)/localize$(HOST_EXECUTABLE_SUFFIX)
+EMMA_JAR := external/emma/lib/emma$(COMMON_JAVA_PACKAGE_SUFFIX)
 
 # Binary prelinker/compressor tools
 APRIORI := $(HOST_OUT_EXECUTABLES)/apriori$(HOST_EXECUTABLE_SUFFIX)
@@ -292,3 +294,4 @@ TARGET_AVAILABLE_SDK_VERSIONS := current \
 INTERNAL_PLATFORM_API_FILE := $(TARGET_OUT_COMMON_INTERMEDIATES)/PACKAGING/public_api.xml
 
 
+
diff --git a/core/definitions.mk b/core/definitions.mk
index a24837b..780d8fb 100644
--- a/core/definitions.mk
+++ b/core/definitions.mk
@@ -243,9 +243,15 @@ endef
 ###########################################################
 
 define find-subdir-assets
-$(if $(1),$(patsubst ./%,%, \
-	$(shell if [ -d $(1) ] ; then cd $(1) ; find ./ -type f -and -not -type l ; fi)), \
-	$(warning Empty argument supplied to find-subdir-assets) \
+$(if $(1),\
+  $(patsubst ./%,%, $(foreach dir,$(1),\
+    $(shell if [ -d $(dir) ] ; then\
+	 cd $(dir) ; find ./ -type f -and -not -type l ;\
+      fi \
+    ) \
+  )) \
+, \
+  $(warning Empty argument supplied to find-subdir-assets) \
 )
 endef
 
@@ -1135,7 +1141,7 @@ $(hide) tr ' ' '\n' < $(PRIVATE_CLASS_INTERMEDIATES_DIR)/java-source-list \
 $(hide) $(TARGET_JAVAC) -encoding ascii $(PRIVATE_BOOTCLASSPATH) \
     $(addprefix -classpath ,$(strip \
         $(call normalize-path-list,$(PRIVATE_ALL_JAVA_LIBRARIES)))) \
-    -g $(xlint_unchecked) \
+    $(strip $(PRIVATE_JAVAC_DEBUG_FLAGS)) $(xlint_unchecked) \
     -extdirs "" -d $(PRIVATE_CLASS_INTERMEDIATES_DIR) \
     \@$(PRIVATE_CLASS_INTERMEDIATES_DIR)/java-source-list-uniq \
     || ( rm -rf $(PRIVATE_CLASS_INTERMEDIATES_DIR) ; exit 41 )
@@ -1147,6 +1153,11 @@ $(hide) jar $(if $(strip $(PRIVATE_JAR_MANIFEST)),-cfm,-cf) \
 @rm -rf $(PRIVATE_CLASS_INTERMEDIATES_DIR)
 endef
 
+define transform-classes.jar-to-emma
+$(hide) java -classpath $(EMMA_JAR) emma instr -outmode fullcopy -outfile \
+    $(PRIVATE_EMMA_COVERAGE_FILE) -ip $< -d $(PRIVATE_EMMA_INTERMEDIATES_DIR)
+endef
+
 #TODO: use a smaller -Xmx value for most libraries;
 #      only core.jar and framework.jar need a heap this big.
 define transform-classes.jar-to-dex
@@ -1477,3 +1488,4 @@ include $(BUILD_SYSTEM)/distdir.mk
 #	  sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
 #	      -e '/^$$/ d' -e 's/$$/ :/' < $*.d >> $*.P; \
 #	  rm -f $*.d
+
diff --git a/core/java.mk b/core/java.mk
index 25baf41..65c525d 100644
--- a/core/java.mk
+++ b/core/java.mk
@@ -66,24 +66,70 @@ ifneq (,$(strip $(all_java_sources)))
 # variable definitions.
 full_classes_jar := $(intermediates.COMMON)/classes.jar
 
+# Emma source code coverage
+ifneq ($(EMMA_INSTRUMENT),true) 
+LOCAL_NO_EMMA_INSTRUMENT := true
+LOCAL_NO_EMMA_COMPILE := true
+endif
+
+ifneq ($(LOCAL_NO_EMMA_COMPILE),true) 
+# If you instrument class files that have local variable debug information in
+# them emma does not correctly maintain the local variable table.
+# This will cause an error when you try to convert the class files for Android.
+# The workaround for this to compile the java classes with only
+# line and source debug information, not local information.
+full_classes_compiled_name_jar := classes-no-debug-var.jar
+$(full_classes_compiled_jar): PRIVATE_JAVAC_DEBUG_FLAGS := -g:{lines,source}
+else
+# when emma is off, compile with the default flags, which contain full debug 
+# info
+full_classes_compiled_name_jar := classes-full-debug.jar
+$(full_classes_compiled_jar): PRIVATE_JAVAC_DEBUG_FLAGS := -g
+endif
+
 # Compile the java files to a .jar file.
 # This intentionally depends on java_sources, not all_java_sources.
 # Deps for generated source files must be handled separately,
 # via deps on the target that generates the sources.
-full_classes_compiled_jar := $(intermediates.COMMON)/classes-compiled.jar
+full_classes_compiled_jar := $(intermediates.COMMON)/$(full_classes_compiled_name_jar)
 $(full_classes_compiled_jar): $(java_sources) $(full_java_lib_deps)
 	$(transform-java-to-classes.jar)
 
+emma_intermediates_dir := $(intermediates.COMMON)/emma_out
+# the 'lib/$(full_classes_compiled_name_jar)' portion of this path is fixed in 
+# the emma tool
+full_classes_emma_jar := $(emma_intermediates_dir)/lib/$(full_classes_compiled_name_jar)
+
+ifeq ($(LOCAL_IS_STATIC_JAVA_LIBRARY),true)
+# Skip adding emma instrumentation to class files if this is a static library,
+# since it will be instrumented by the package that includes it
+LOCAL_NO_EMMA_INSTRUMENT:= true
+endif
+
+ifneq ($(LOCAL_NO_EMMA_INSTRUMENT),true)
+$(full_classes_emma_jar): PRIVATE_EMMA_COVERAGE_FILE := $(intermediates.COMMON)/coverage.em
+$(full_classes_emma_jar): PRIVATE_EMMA_INTERMEDIATES_DIR := $(emma_intermediates_dir)
+# this rule will generate both $(PRIVATE_EMMA_COVERAGE_FILE) and
+# $(full_classes_emma_jar)
+$(full_classes_emma_jar): $(full_classes_compiled_jar)
+	$(transform-classes.jar-to-emma)
+$(PRIVATE_EMMA_COVERAGE_FILE): $(full_classes_emma_jar)
+else
+$(full_classes_emma_jar): $(full_classes_compiled_jar) | $(ACP)
+	@echo Copying $<
+	$(copy-file-to-target)
+endif
+
 # Run jarjar if necessary, otherwise just copy the file.  This is the last
 # part of this step, so the output of this command is full_classes_jar.
 full_classes_jarjar_jar := $(full_classes_jar)
 ifneq ($(strip $(LOCAL_JARJAR_RULES)),)
 $(full_classes_jarjar_jar): PRIVATE_JARJAR_RULES := $(LOCAL_JARJAR_RULES)
-$(full_classes_jarjar_jar): $(full_classes_compiled_jar) | jarjar
+$(full_classes_jarjar_jar): $(full_classes_emma_jar) | jarjar
 	@echo JarJar: $@
 	$(hide) $(JARJAR) process $(PRIVATE_JARJAR_RULES) $< $@
 else
-$(full_classes_jarjar_jar): $(full_classes_compiled_jar) | $(ACP)
+$(full_classes_jarjar_jar): $(full_classes_emma_jar) | $(ACP)
 	@echo Copying: $@
 	$(hide) $(ACP) $< $@
 endif
diff --git a/core/main.mk b/core/main.mk
index 4a1519c..4f97b33 100644
--- a/core/main.mk
+++ b/core/main.mk
@@ -165,7 +165,7 @@ ifneq ($(filter sdk,$(MAKECMDGOALS)),)
 ifneq ($(words $(filter-out $(INTERNAL_MODIFIER_TARGETS),$(MAKECMDGOALS))),1)
 $(error The 'sdk' target may not be specified with any other targets)
 endif
-override_build_tags := development
+override_build_tags := user
 ADDITIONAL_BUILD_PROPERTIES += xmpp.auto-presence=true
 ADDITIONAL_BUILD_PROPERTIES += ro.config.nocheckin=yes
 else # !sdk
@@ -488,35 +488,12 @@ eng_MODULES := $(sort $(call get-tagged-modules,eng,restricted))
 debug_MODULES := $(sort $(call get-tagged-modules,debug,restricted))
 tests_MODULES := $(sort $(call get-tagged-modules,tests,restricted))
 
-# Don't include any GNU targets in the SDK.  It's ok (and necessary)
-# to build the host tools, but nothing that's going to be installed
-# on the target (including static libraries).
-all_development_MODULES := \
-	$(sort $(call get-tagged-modules,development,restricted))
-target_gnu_MODULES := \
-	$(filter \
-		$(TARGET_OUT_INTERMEDIATES)/% \
-		$(TARGET_OUT)/% \
-		$(TARGET_OUT_DATA)/%, \
-	    $(sort $(call get-tagged-modules,gnu)))
-#$(info Removing from development:)$(foreach d,$(target_gnu_MODULES),$(info : $(d)))
-development_MODULES := \
-	$(filter-out $(target_gnu_MODULES),$(all_development_MODULES))
-
 droid_MODULES := $(sort $(Default_MODULES) \
 			$(eng_MODULES) \
 			$(debug_MODULES) \
 			$(user_MODULES) \
 			$(all_development_MODULES))
 
-# The list of everything that's not on droid_MODULES.
-# Also skip modules tagged as "restricted", which are
-# never installed unless explicitly mentioned in
-# CUSTOM_MODULES.
-nonDroid_MODULES := $(sort $(call get-tagged-modules,\
-			  $(ALL_MODULE_TAGS),\
-			  eng debug user development restricted))
-
 # THIS IS A TOTAL HACK AND SHOULD NOT BE USED AS AN EXAMPLE
 modules_to_build := $(droid_MODULES)
 ifneq ($(override_build_tags),)
@@ -536,6 +513,22 @@ ifdef overridden_packages
 endif
 #$(error filtered out $(filter-out $(modules_to_build),$(old_modules_to_build)))
 
+# Don't include any GNU targets in the SDK.  It's ok (and necessary)
+# to build the host tools, but nothing that's going to be installed
+# on the target (including static libraries).
+ifneq ($(filter sdk,$(MAKECMDGOALS)),)
+  target_gnu_MODULES := \
+              $(filter \
+                      $(TARGET_OUT_INTERMEDIATES)/% \
+                      $(TARGET_OUT)/% \
+                      $(TARGET_OUT_DATA)/%, \
+                              $(sort $(call get-tagged-modules,gnu)))
+  $(info Removing from sdk:)$(foreach d,$(target_gnu_MODULES),$(info : $(d)))
+  modules_to_build := \
+              $(filter-out $(target_gnu_MODULES),$(modules_to_build))
+endif
+
+
 # config/Makefile contains extra stuff that we don't want to pollute this
 # top-level makefile with.  It expects that ALL_DEFAULT_INSTALLED_MODULES
 # contains everything that's built during the current make, but it also further
diff --git a/core/package.mk b/core/package.mk
index 07690ad..ba41495 100644
--- a/core/package.mk
+++ b/core/package.mk
@@ -65,7 +65,8 @@ LOCAL_ASSET_DIR := $(LOCAL_PATH)/assets
 endif
 
 ifeq (,$(LOCAL_RESOURCE_DIR))
-LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res
+LOCAL_RESOURCE_DIR := $(wildcard $(addsuffix /$(LOCAL_PATH)/res, $(PRODUCT_PACKAGE_OVERLAYS))) \
+  $(LOCAL_PATH)/res
 endif
 
 # this is an app, so add the system libraries to the search path
diff --git a/core/pathmap.mk b/core/pathmap.mk
index 5498898..13cb80d 100644
--- a/core/pathmap.mk
+++ b/core/pathmap.mk
@@ -39,6 +39,7 @@ pathmap_INCL := \
     libdrm1:frameworks/base/media/libdrm/mobile1/include \
     libdrm2:frameworks/base/media/libdrm/mobile2/include \
     libhardware:hardware/libhardware/include \
+    libhardware_legacy:hardware/libhardware_legacy/include \
     libhost:build/libs/host/include \
     libm:bionic/libm/include \
     libnativehelper:dalvik/libnativehelper/include \
diff --git a/core/prelink-linux-arm.map b/core/prelink-linux-arm.map
index 2e90322..413dcc4 100644
--- a/core/prelink-linux-arm.map
+++ b/core/prelink-linux-arm.map
@@ -75,7 +75,8 @@ libexpat.so             0xAAB00000
 libwebcore.so           0xAA000000
 libutils.so             0xA9D00000
 libcameraservice.so     0xA9C80000
-libhardware.so          0xA9C00000
+libhardware.so          0xA9C70000
+libhardware_legacy.so   0xA9C00000
 libapp_process.so       0xA9B00000
 libsystem_server.so     0xA9A00000
 libime.so               0xA9800000
diff --git a/core/product.mk b/core/product.mk
index 2406b06..08019e8 100644
--- a/core/product.mk
+++ b/core/product.mk
@@ -66,7 +66,8 @@ _product_var_list := \
     PRODUCT_PROPERTY_OVERRIDES \
     PRODUCT_COPY_FILES \
     PRODUCT_OTA_PUBLIC_KEYS \
-    PRODUCT_POLICY
+    PRODUCT_POLICY \
+    PRODUCT_PACKAGE_OVERLAYS
 
 define dump-product
 $(info ==== $(1) ====)\
diff --git a/core/product_config.mk b/core/product_config.mk
index 1031fa1..436f9f6 100644
--- a/core/product_config.mk
+++ b/core/product_config.mk
@@ -186,6 +186,10 @@ PRODUCT_COPY_FILES := \
 PRODUCT_PROPERTY_OVERRIDES := \
 	$(strip $(PRODUCTS.$(INTERNAL_PRODUCT).PRODUCT_PROPERTY_OVERRIDES))
 
+# Should we use the default resources or add any product specific overlays
+PRODUCT_PACKAGE_OVERLAYS := \
+	$(strip $(PRODUCTS.$(INTERNAL_PRODUCT).PRODUCT_PACKAGE_OVERLAYS))
+
 # Add the product-defined properties to the build properties.
 ADDITIONAL_BUILD_PROPERTIES := \
 	$(ADDITIONAL_BUILD_PROPERTIES) \
diff --git a/target/product/sdk.mk b/target/product/sdk.mk
index ae8fa45..e6254f4 100644
--- a/target/product/sdk.mk
+++ b/target/product/sdk.mk
@@ -1,10 +1,23 @@
 PRODUCT_PROPERTY_OVERRIDES :=
 
 PRODUCT_PACKAGES := \
+	AlarmClock \
 	ApiDemos \
+	Camera \
 	Development \
+	DrmProvider \
+	Email \
 	Fallback \
-	GPSEnable
+	GPSEnable \
+	Launcher \
+	Maps \
+	Music \
+	Mms \
+	Settings \
+	SdkSetup \
+	gpstest \
+	sqlite3
+
 
 $(call inherit-product, $(SRC_TARGET_DIR)/product/core.mk)
 
diff --git a/tools/applypatch/Android.mk b/tools/applypatch/Android.mk
new file mode 100644
index 0000000..725c21f
--- /dev/null
+++ b/tools/applypatch/Android.mk
@@ -0,0 +1,29 @@
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+ifneq ($(TARGET_SIMULATOR),true)
+
+LOCAL_SRC_FILES := applypatch.c xdelta3.c bsdiff.c freecache.c
+LOCAL_MODULE := applypatch
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+LOCAL_MODULE_TAGS := eng
+LOCAL_C_INCLUDES += external/xdelta3 external/bzip2
+LOCAL_STATIC_LIBRARIES += libxdelta3 libmincrypt libbz libc
+
+include $(BUILD_EXECUTABLE)
+
+endif  # !TARGET_SIMULATOR
diff --git a/tools/applypatch/applypatch.c b/tools/applypatch/applypatch.c
new file mode 100644
index 0000000..23ed715
--- /dev/null
+++ b/tools/applypatch/applypatch.c
@@ -0,0 +1,482 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include <errno.h>
+#include <libgen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <unistd.h>
+
+#include "mincrypt/sha.h"
+#include "applypatch.h"
+
+// Read a file into memory; store it and its associated metadata in
+// *file.  Return 0 on success.
+int LoadFileContents(const char* filename, FileContents* file) {
+  file->data = NULL;
+
+  if (stat(filename, &file->st) != 0) {
+    fprintf(stderr, "failed to stat \"%s\": %s\n", filename, strerror(errno));
+    return -1;
+  }
+
+  file->size = file->st.st_size;
+  file->data = malloc(file->size);
+
+  FILE* f = fopen(filename, "rb");
+  if (f == NULL) {
+    fprintf(stderr, "failed to open \"%s\": %s\n", filename, strerror(errno));
+    free(file->data);
+    return -1;
+  }
+
+  size_t bytes_read = fread(file->data, 1, file->size, f);
+  if (bytes_read != file->size) {
+    fprintf(stderr, "short read of \"%s\" (%d bytes of %d)\n",
+            filename, bytes_read, file->size);
+    free(file->data);
+    return -1;
+  }
+  fclose(f);
+
+  SHA(file->data, file->size, file->sha1);
+  return 0;
+}
+
+// Save the contents of the given FileContents object under the given
+// filename.  Return 0 on success.
+int SaveFileContents(const char* filename, FileContents file) {
+  FILE* f = fopen(filename, "wb");
+  if (f == NULL) {
+    fprintf(stderr, "failed to open \"%s\" for write: %s\n",
+            filename, strerror(errno));
+    return -1;
+  }
+
+  size_t bytes_written = fwrite(file.data, 1, file.size, f);
+  if (bytes_written != file.size) {
+    fprintf(stderr, "short write of \"%s\" (%d bytes of %d)\n",
+            filename, bytes_written, file.size);
+    return -1;
+  }
+  fflush(f);
+  fsync(fileno(f));
+  fclose(f);
+
+  if (chmod(filename, file.st.st_mode) != 0) {
+    fprintf(stderr, "chmod of \"%s\" failed: %s\n", filename, strerror(errno));
+    return -1;
+  }
+  if (chown(filename, file.st.st_uid, file.st.st_gid) != 0) {
+    fprintf(stderr, "chown of \"%s\" failed: %s\n", filename, strerror(errno));
+    return -1;
+  }
+
+  return 0;
+}
+
+
+// Take a string 'str' of 40 hex digits and parse it into the 20
+// byte array 'digest'.  'str' may contain only the digest or be of
+// the form "<digest>:<anything>".  Return 0 on success, -1 on any
+// error.
+int ParseSha1(const char* str, uint8_t* digest) {
+  int i;
+  const char* ps = str;
+  uint8_t* pd = digest;
+  for (i = 0; i < SHA_DIGEST_SIZE * 2; ++i, ++ps) {
+    int digit;
+    if (*ps >= '0' && *ps <= '9') {
+      digit = *ps - '0';
+    } else if (*ps >= 'a' && *ps <= 'f') {
+      digit = *ps - 'a' + 10;
+    } else if (*ps >= 'A' && *ps <= 'F') {
+      digit = *ps - 'A' + 10;
+    } else {
+      return -1;
+    }
+    if (i % 2 == 0) {
+      *pd = digit << 4;
+    } else {
+      *pd |= digit;
+      ++pd;
+    }
+  }
+  if (*ps != '\0' && *ps != ':') return -1;
+  return 0;
+}
+
+// Parse arguments (which should be of the form "<sha1>" or
+// "<sha1>:<filename>" into the array *patches, returning the number
+// of Patch objects in *num_patches.  Return 0 on success.
+int ParseShaArgs(int argc, char** argv, Patch** patches, int* num_patches) {
+  *num_patches = argc;
+  *patches = malloc(*num_patches * sizeof(Patch));
+
+  int i;
+  for (i = 0; i < *num_patches; ++i) {
+    if (ParseSha1(argv[i], (*patches)[i].sha1) != 0) {
+      fprintf(stderr, "failed to parse sha1 \"%s\"\n", argv[i]);
+      return -1;
+    }
+    if (argv[i][SHA_DIGEST_SIZE*2] == '\0') {
+      (*patches)[i].patch_filename = NULL;
+    } else if (argv[i][SHA_DIGEST_SIZE*2] == ':') {
+      (*patches)[i].patch_filename = argv[i] + (SHA_DIGEST_SIZE*2+1);
+    } else {
+      fprintf(stderr, "failed to parse filename \"%s\"\n", argv[i]);
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+// Search an array of Patch objects for one matching the given sha1.
+// Return the Patch object on success, or NULL if no match is found.
+const Patch* FindMatchingPatch(uint8_t* sha1, Patch* patches, int num_patches) {
+  int i;
+  for (i = 0; i < num_patches; ++i) {
+    if (memcmp(patches[i].sha1, sha1, SHA_DIGEST_SIZE) == 0) {
+      return patches+i;
+    }
+  }
+  return NULL;
+}
+
+// Returns 0 if the contents of the file (argv[2]) or the cached file
+// match any of the sha1's on the command line (argv[3:]).  Returns
+// nonzero otherwise.
+int CheckMode(int argc, char** argv) {
+  if (argc < 3) {
+    fprintf(stderr, "no filename given\n");
+    return 2;
+  }
+
+  int num_patches;
+  Patch* patches;
+  if (ParseShaArgs(argc-3, argv+3, &patches, &num_patches) != 0) { return 1; }
+
+  FileContents file;
+  file.data = NULL;
+
+  if (LoadFileContents(argv[2], &file) != 0 ||
+      FindMatchingPatch(file.sha1, patches, num_patches) == NULL) {
+    fprintf(stderr, "file \"%s\" doesn't have any of expected "
+            "sha1 sums; checking cache\n", argv[2]);
+
+    free(file.data);
+
+    // If the source file is missing or corrupted, it might be because
+    // we were killed in the middle of patching it.  A copy of it
+    // should have been made in CACHE_TEMP_SOURCE.  If that file
+    // exists and matches the sha1 we're looking for, the check still
+    // passes.
+
+    if (LoadFileContents(CACHE_TEMP_SOURCE, &file) != 0) {
+      fprintf(stderr, "failed to load cache file\n");
+      return 1;
+    }
+
+    if (FindMatchingPatch(file.sha1, patches, num_patches) == NULL) {
+      fprintf(stderr, "cache bits don't match any sha1 for \"%s\"\n",
+              argv[2]);
+      return 1;
+    }
+  }
+
+  free(file.data);
+  return 0;
+}
+
+int ShowLicenses() {
+  puts("\nCopyright (C) 2008 The Android Open Source Project\n"
+       "\n"
+       "This program is free software; you can redistribute it and/or\n"
+       "modify it under the terms of the GNU General Public License\n"
+       "as published by the Free Software Foundation; either version 2\n"
+       "of the License, or (at your option) any later version.\n"
+       "\n"
+       "This program is distributed in the hope that it will be useful,\n"
+       "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+       "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
+       "GNU General Public License for more details.\n"
+       "\n"
+       "You should have received a copy of the GNU General Public License\n"
+       "along with this program; if not, write to the Free Software\n"
+       "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n"
+       "02110-1301, USA.\n"
+       "\n------------------\n"
+       );
+  ShowBSDiffLicense();
+  return 0;
+}
+
+// Return the amount of free space (in bytes) on the filesystem
+// containing filename.  filename must exist.  Return -1 on error.
+size_t FreeSpaceForFile(const char* filename) {
+  struct statfs sf;
+  if (statfs(filename, &sf) != 0) {
+    fprintf(stderr, "failed to statfs %s: %s\n", filename, strerror(errno));
+    return -1;
+  }
+  return sf.f_bsize * sf.f_bfree;
+}
+
+// This program applies binary patches to files in a way that is safe
+// (the original file is not touched until we have the desired
+// replacement for it) and idempotent (it's okay to run this program
+// multiple times).
+//
+// - if the sha1 hash of <file> is <tgt-sha1>, does nothing and exits
+//   successfully.
+//
+// - otherwise, if the sha1 hash of <file> is <src-sha1>, applies the
+//   xdelta3 or bsdiff <patch> to <file> to produce a new file (the
+//   type of patch is automatically detected from the file header).
+//   If that new file has sha1 hash <tgt-sha1>, moves it to replace
+//   <file>, and exits successfully.
+//
+// - otherwise, or if any error is encountered, exits with non-zero
+//   status.
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+ usage:
+    fprintf(stderr, "usage: %s <file> <tgt-sha1> <tgt-size> [<src-sha1>:<patch> ...]\n"
+                    "   or  %s -c <file> [<sha1> ...]\n"
+                    "   or  %s -s <bytes>\n"
+                    "   or  %s -l\n",
+            argv[0], argv[0], argv[0], argv[0]);
+    return 1;
+  }
+
+  if (strncmp(argv[1], "-l", 3) == 0) {
+    return ShowLicenses();
+  }
+
+  if (strncmp(argv[1], "-c", 3) == 0) {
+    return CheckMode(argc, argv);
+  }
+
+  if (strncmp(argv[1], "-s", 3) == 0) {
+    if (argc != 3) {
+      goto usage;
+    }
+    size_t bytes = strtol(argv[2], NULL, 10);
+    if (MakeFreeSpaceOnCache(bytes) < 0) {
+      printf("unable to make %ld bytes available on /cache\n", (long)bytes);
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  uint8_t target_sha1[SHA_DIGEST_SIZE];
+
+  const char* source_filename = argv[1];
+
+  // assume that source_filename (eg "/system/app/Foo.apk") is located
+  // on the same filesystem as its top-level directory ("/system").
+  // We need something that exists for calling statfs().
+  char* source_fs = strdup(argv[1]);
+  char* slash = strchr(source_fs+1, '/');
+  if (slash != NULL) {
+    *slash = '\0';
+  }
+
+  if (ParseSha1(argv[2], target_sha1) != 0) {
+    fprintf(stderr, "failed to parse tgt-sha1 \"%s\"\n", argv[2]);
+    return 1;
+  }
+
+  unsigned long target_size = strtoul(argv[3], NULL, 0);
+
+  int num_patches;
+  Patch* patches;
+  if (ParseShaArgs(argc-4, argv+4, &patches, &num_patches) < 0) { return 1; }
+
+  FileContents copy_file;
+  FileContents source_file;
+  const char* source_patch_filename = NULL;
+  const char* copy_patch_filename = NULL;
+  int made_copy = 0;
+
+  if (LoadFileContents(source_filename, &source_file) == 0) {
+    if (memcmp(source_file.sha1, target_sha1, SHA_DIGEST_SIZE) == 0) {
+      // The early-exit case:  the patch was already applied, this file
+      // has the desired hash, nothing for us to do.
+      fprintf(stderr, "\"%s\" is already target; no patch needed\n",
+              source_filename);
+      return 0;
+    }
+
+    const Patch* to_use =
+        FindMatchingPatch(source_file.sha1, patches, num_patches);
+    if (to_use != NULL) {
+      source_patch_filename = to_use->patch_filename;
+    }
+  }
+
+  if (source_patch_filename == NULL) {
+    free(source_file.data);
+    fprintf(stderr, "source file is bad; trying copy\n");
+
+    if (LoadFileContents(CACHE_TEMP_SOURCE, &copy_file) < 0) {
+      // fail.
+      fprintf(stderr, "failed to read copy file\n");
+      return 1;
+    }
+
+    const Patch* to_use =
+        FindMatchingPatch(copy_file.sha1, patches, num_patches);
+    if (to_use != NULL) {
+      copy_patch_filename = to_use->patch_filename;
+    }
+
+    if (copy_patch_filename == NULL) {
+      // fail.
+      fprintf(stderr, "copy file doesn't match source SHA-1s either\n");
+      return 1;
+    }
+  }
+
+  // Is there enough room in the target filesystem to hold the patched file?
+  size_t free_space = FreeSpaceForFile(source_fs);
+  int enough_space = free_space > (target_size * 3 / 2);  // 50% margin of error
+  printf("target %ld bytes; free space %ld bytes; enough %d\n",
+         (long)target_size, (long)free_space, enough_space);
+
+  if (!enough_space && source_patch_filename != NULL) {
+    // Using the original source, but not enough free space.  First
+    // copy the source file to cache, then delete it from the original
+    // location.
+    if (MakeFreeSpaceOnCache(source_file.size) < 0) {
+      fprintf(stderr, "not enough free space on /cache\n");
+      return 1;
+    }
+
+    if (SaveFileContents(CACHE_TEMP_SOURCE, source_file) < 0) {
+      fprintf(stderr, "failed to back up source file\n");
+      return 1;
+    }
+    made_copy = 1;
+    unlink(source_filename);
+
+    size_t free_space = FreeSpaceForFile(source_fs);
+    printf("(now %ld bytes free for source)\n", (long)free_space);
+  }
+
+  FileContents* source_to_use;
+  const char* patch_filename;
+  if (source_patch_filename != NULL) {
+    source_to_use = &source_file;
+    patch_filename = source_patch_filename;
+  } else {
+    source_to_use = &copy_file;
+    patch_filename = copy_patch_filename;
+  }
+
+  // We write the decoded output to "<file>.patch".
+  char* outname = (char*)malloc(strlen(source_filename) + 10);
+  strcpy(outname, source_filename);
+  strcat(outname, ".patch");
+  FILE* output = fopen(outname, "wb");
+  if (output == NULL) {
+    fprintf(stderr, "failed to patch file %s: %s\n",
+            source_filename, strerror(errno));
+    return 1;
+  }
+
+#define MAX_HEADER_LENGTH 8
+  unsigned char header[MAX_HEADER_LENGTH];
+  FILE* patchf = fopen(patch_filename, "rb");
+  if (patchf == NULL) {
+    fprintf(stderr, "failed to open patch file %s: %s\n",
+            patch_filename, strerror(errno));
+    return 1;
+  }
+  int header_bytes_read = fread(header, 1, MAX_HEADER_LENGTH, patchf);
+  fclose(patchf);
+
+  SHA_CTX ctx;
+  SHA_init(&ctx);
+
+  if (header_bytes_read >= 4 &&
+      header[0] == 0xd6 && header[1] == 0xc3 &&
+      header[2] == 0xc4 && header[3] == 0) {
+    // xdelta3 patches begin "VCD" (with the high bits set) followed
+    // by a zero byte (the version number).
+    int result = ApplyXDelta3Patch(source_to_use->data, source_to_use->size,
+                                   patch_filename, output, &ctx);
+    if (result != 0) {
+      fprintf(stderr, "ApplyXDelta3Patch failed\n");
+      return result;
+    }
+  } else if (header_bytes_read >= 8 &&
+             memcmp(header, "BSDIFF40", 8) == 0) {
+    int result = ApplyBSDiffPatch(source_to_use->data, source_to_use->size,
+                                  patch_filename, output, &ctx);
+    if (result != 0) {
+      fprintf(stderr, "ApplyBSDiffPatch failed\n");
+      return result;
+    }
+  } else {
+    fprintf(stderr, "Unknown patch file format");
+    return 1;
+  }
+
+  fflush(output);
+  fsync(fileno(output));
+  fclose(output);
+
+  const uint8_t* current_target_sha1 = SHA_final(&ctx);
+  if (memcmp(current_target_sha1, target_sha1, SHA_DIGEST_SIZE) != 0) {
+    fprintf(stderr, "patch did not produce expected sha1\n");
+    return 1;
+  }
+
+  // Give the .patch file the same owner, group, and mode of the
+  // original source file.
+  if (chmod(outname, source_to_use->st.st_mode) != 0) {
+    fprintf(stderr, "chmod of \"%s\" failed: %s\n", outname, strerror(errno));
+    return 1;
+  }
+  if (chown(outname, source_to_use->st.st_uid, source_to_use->st.st_gid) != 0) {
+    fprintf(stderr, "chown of \"%s\" failed: %s\n", outname, strerror(errno));
+    return 1;
+  }
+
+  // Finally, rename the .patch file to replace the original source file.
+  if (rename(outname, source_filename) != 0) {
+    fprintf(stderr, "rename of .patch to \"%s\" failed: %s\n",
+            source_filename, strerror(errno));
+    return 1;
+  }
+
+  // If this run of applypatch created the copy, and we're here, we
+  // can delete it.
+  if (made_copy) unlink(CACHE_TEMP_SOURCE);
+
+  // Success!
+  return 0;
+}
diff --git a/tools/applypatch/applypatch.h b/tools/applypatch/applypatch.h
new file mode 100644
index 0000000..3059e22
--- /dev/null
+++ b/tools/applypatch/applypatch.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#ifndef _APPLYPATCH_H
+#define _APPLYPATCH_H
+
+#include "mincrypt/sha.h"
+
+typedef struct _Patch {
+  uint8_t sha1[SHA_DIGEST_SIZE];
+  const char* patch_filename;
+} Patch;
+
+typedef struct _FileContents {
+  uint8_t sha1[SHA_DIGEST_SIZE];
+  unsigned char* data;
+  size_t size;
+  struct stat st;
+} FileContents;
+
+// When there isn't enough room on the target filesystem to hold the
+// patched version of the file, we copy the original here and delete
+// it to free up space.  If the expected source file doesn't exist, or
+// is corrupted, we look to see if this file contains the bits we want
+// and use it as the source instead.
+#define CACHE_TEMP_SOURCE "/cache/saved.file"
+
+// applypatch.c
+size_t FreeSpaceForFile(const char* filename);
+
+// xdelta3.c
+int ApplyXDelta3Patch(const unsigned char* old_data, ssize_t old_size,
+                      const char* patch_filename,
+                      FILE* output, SHA_CTX* ctx);
+
+// bsdiff.c
+void ShowBSDiffLicense();
+int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
+                     const char* patch_filename,
+                     FILE* output, SHA_CTX* ctx);
+
+// freecache.c
+int MakeFreeSpaceOnCache(size_t bytes_needed);
+
+#endif
diff --git a/tools/applypatch/applypatch.sh b/tools/applypatch/applypatch.sh
new file mode 100755
index 0000000..193e7fd
--- /dev/null
+++ b/tools/applypatch/applypatch.sh
@@ -0,0 +1,299 @@
+#!/bin/bash
+#
+# A test suite for applypatch.  Run in a client where you have done
+# envsetup, choosecombo, etc.
+#
+# DO NOT RUN THIS ON A DEVICE YOU CARE ABOUT.  It will mess up your
+# system partition.
+#
+#
+# TODO: find some way to get this run regularly along with the rest of
+# the tests.
+
+EMULATOR_PORT=5580
+DATA_DIR=$ANDROID_BUILD_TOP/build/tools/applypatch/testdata
+
+# This must be the filename that applypatch uses for its copies.
+CACHE_TEMP_SOURCE=/cache/saved.file
+
+# Put all binaries and files here.  We use /cache because it's a
+# temporary filesystem in the emulator; it's created fresh each time
+# the emulator starts.
+WORK_DIR=/system
+
+# partition that WORK_DIR is located on, without the leading slash
+WORK_FS=system
+
+# ------------------------
+
+tmpdir=$(mktemp -d)
+
+emulator -wipe-data -noaudio -no-window -port $EMULATOR_PORT &
+pid_emulator=$!
+
+ADB="adb -s emulator-$EMULATOR_PORT "
+
+echo "emulator is $pid_emulator; waiting for startup"
+$ADB wait-for-device
+echo "device is available"
+$ADB remount
+# free up enough space on the system partition for the test to run.
+$ADB shell rm -r /system/media
+
+# run a command on the device; exit with the exit status of the device
+# command.
+run_command() {
+  $ADB shell "$@" \; echo \$? | awk '{if (b) {print a}; a=$0; b=1} END {exit a}'
+}
+
+testname() {
+  echo
+  echo "$1"...
+  testname="$1"
+}
+
+fail() {
+  echo
+  echo FAIL: $testname
+  echo
+  kill $pid_emulator
+  exit 1
+}
+
+sha1() {
+  sha1sum $1 | awk '{print $1}'
+}
+
+free_space() {
+  run_command df | awk "/$1/ {print gensub(/K/, \"\", \"g\", \$6)}"
+}
+
+
+$ADB push $ANDROID_PRODUCT_OUT/system/bin/applypatch $WORK_DIR/applypatch
+
+BAD1_SHA1=$(printf "%040x" $RANDOM)
+BAD2_SHA1=$(printf "%040x" $RANDOM)
+OLD_SHA1=$(sha1 $DATA_DIR/old.file)
+NEW_SHA1=$(sha1 $DATA_DIR/new.file)
+NEW_SIZE=$(stat -c %s $DATA_DIR/new.file)
+
+# --------------- basic execution ----------------------
+
+testname "usage message"
+run_command $WORK_DIR/applypatch && fail
+
+testname "display license"
+run_command $WORK_DIR/applypatch -l | grep -q -i copyright || fail
+
+
+# --------------- check mode ----------------------
+
+$ADB push $DATA_DIR/old.file $WORK_DIR
+
+testname "check mode single"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $OLD_SHA1 || fail
+
+testname "check mode multiple"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD1_SHA1 $OLD_SHA1 $BAD2_SHA1|| fail
+
+testname "check mode failure"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD2_SHA1 $BAD1_SHA1 && fail
+
+$ADB push $DATA_DIR/old.file $CACHE_TEMP_SOURCE
+# put some junk in the old file
+run_command dd if=/dev/urandom of=$WORK_DIR/old.file count=100 bs=1024 || fail
+
+testname "check mode cache (corrupted) single"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $OLD_SHA1 || fail
+
+testname "check mode cache (corrupted) multiple"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD1_SHA1 $OLD_SHA1 $BAD2_SHA1|| fail
+
+testname "check mode cache (corrupted) failure"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD2_SHA1 $BAD1_SHA1 && fail
+
+# remove the old file entirely
+run_command rm $WORK_DIR/old.file
+
+testname "check mode cache (missing) single"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $OLD_SHA1 || fail
+
+testname "check mode cache (missing) multiple"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD1_SHA1 $OLD_SHA1 $BAD2_SHA1|| fail
+
+testname "check mode cache (missing) failure"
+run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD2_SHA1 $BAD1_SHA1 && fail
+
+
+# --------------- apply patch ----------------------
+
+$ADB push $DATA_DIR/old.file $WORK_DIR
+$ADB push $DATA_DIR/patch.xdelta3 $WORK_DIR
+
+# Check that the partition has enough space to apply the patch without
+# copying.  If it doesn't, we'll be testing the low-space condition
+# when we intend to test the not-low-space condition.
+testname "apply patches (with enough space)"
+free_kb=$(free_space $WORK_FS)
+echo "${free_kb}kb free on /$WORK_FS."
+if (( free_kb * 1024 < NEW_SIZE * 3 / 2 )); then
+  echo "Not enough space on /$WORK_FS to patch test file."
+  echo
+  echo "This doesn't mean that applypatch is necessarily broken;"
+  echo "just that /$WORK_FS doesn't have enough free space to"
+  echo "properly run this test."
+  exit 1
+fi
+
+testname "apply xdelta3 patch"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.xdelta3 || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+testname "reapply xdelta3 patch"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.xdelta3 || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+$ADB push $DATA_DIR/old.file $WORK_DIR
+$ADB push $DATA_DIR/patch.bsdiff $WORK_DIR
+
+testname "apply bsdiff patch"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+testname "reapply bsdiff patch"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+
+# --------------- apply patch with low space on /system ----------------------
+
+$ADB push $DATA_DIR/old.file $WORK_DIR
+$ADB push $DATA_DIR/patch.xdelta3 $WORK_DIR
+$ADB push $DATA_DIR/patch.bsdiff $WORK_DIR
+
+free_kb=$(free_space $WORK_FS)
+echo "${free_kb}kb free on /$WORK_FS; we'll soon fix that."
+echo run_command dd if=/dev/zero of=$WORK_DIR/bloat.dat count=$((free_kb-512)) bs=1024 || fail
+run_command dd if=/dev/zero of=$WORK_DIR/bloat.dat count=$((free_kb-512)) bs=1024 || fail
+free_kb=$(free_space $WORK_FS)
+echo "${free_kb}kb free on /$WORK_FS now."
+
+testname "apply xdelta3 patch with low space"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.xdelta3 || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+testname "reapply xdelta3 patch with low space"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.xdelta3 || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+$ADB push $DATA_DIR/old.file $WORK_DIR
+
+testname "apply bsdiff patch with low space"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+testname "reapply bsdiff patch with low space"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+# --------------- apply patch with low space on /system and /cache ----------------------
+
+$ADB push $DATA_DIR/old.file $WORK_DIR
+$ADB push $DATA_DIR/patch.xdelta3 $WORK_DIR
+$ADB push $DATA_DIR/patch.bsdiff $WORK_DIR
+
+free_kb=$(free_space $WORK_FS)
+echo "${free_kb}kb free on /$WORK_FS"
+
+run_command mkdir /cache/subdir
+run_command 'echo > /cache/subdir/a.file'
+run_command 'echo > /cache/a.file'
+run_command mkdir -p /cache/recovery/otatest
+run_command 'echo > /cache/recovery/otatest/b.file'
+run_command "echo > $CACHE_TEMP_SOURCE"
+free_kb=$(free_space cache)
+echo "${free_kb}kb free on /cache; we'll soon fix that."
+run_command dd if=/dev/zero of=/cache/bloat_small.dat count=128 bs=1024 || fail
+run_command dd if=/dev/zero of=/cache/bloat_large.dat count=$((free_kb-640)) bs=1024 || fail
+free_kb=$(free_space cache)
+echo "${free_kb}kb free on /cache now."
+
+testname "apply bsdiff patch with low space, full cache, can't delete enough"
+$ADB shell 'cat >> /cache/bloat_large.dat' & open_pid=$!
+echo "open_pid is $open_pid"
+
+# size check should fail even though it deletes some stuff
+run_command $WORK_DIR/applypatch -s $NEW_SIZE && fail
+run_command ls /cache/bloat_small.dat && fail          # was deleted
+run_command ls /cache/a.file && fail                   # was deleted
+run_command ls /cache/recovery/otatest/b.file && fail  # was deleted
+run_command ls /cache/bloat_large.dat || fail          # wasn't deleted because it was open
+run_command ls /cache/subdir/a.file || fail            # wasn't deleted because it's in a subdir
+run_command ls $CACHE_TEMP_SOURCE || fail              # wasn't deleted because it's the source file copy
+
+# should fail; not enough files can be deleted
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff && fail
+run_command ls /cache/bloat_large.dat || fail   # wasn't deleted because it was open
+run_command ls /cache/subdir/a.file || fail     # wasn't deleted because it's in a subdir
+run_command ls $CACHE_TEMP_SOURCE || fail       # wasn't deleted because it's the source file copy
+
+kill $open_pid   # /cache/bloat_large.dat is no longer open
+
+testname "apply bsdiff patch with low space, full cache, can delete enough"
+
+# should succeed after deleting /cache/bloat_large.dat
+run_command $WORK_DIR/applypatch -s $NEW_SIZE || fail
+run_command ls /cache/bloat_large.dat && fail   # was deleted
+run_command ls /cache/subdir/a.file || fail     # still wasn't deleted because it's in a subdir
+run_command ls $CACHE_TEMP_SOURCE || fail       # wasn't deleted because it's the source file copy
+
+# should succeed
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+run_command ls /cache/subdir/a.file || fail     # still wasn't deleted because it's in a subdir
+run_command ls $CACHE_TEMP_SOURCE && fail       # was deleted because patching overwrote it, then deleted it
+
+# --------------- apply patch from cache ----------------------
+
+$ADB push $DATA_DIR/old.file $CACHE_TEMP_SOURCE
+# put some junk in the old file
+run_command dd if=/dev/urandom of=$WORK_DIR/old.file count=100 bs=1024 || fail
+
+testname "apply xdelta3 patch from cache (corrupted source) with low space"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.xdelta3 || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+$ADB push $DATA_DIR/old.file $CACHE_TEMP_SOURCE
+# remove the old file entirely
+run_command rm $WORK_DIR/old.file
+
+testname "apply bsdiff patch from cache (missing source) with low space"
+run_command $WORK_DIR/applypatch $WORK_DIR/old.file $NEW_SHA1 $NEW_SIZE $BAD1_SHA1:$WORK_DIR/foo $OLD_SHA1:$WORK_DIR/patch.bsdiff || fail
+$ADB pull $WORK_DIR/old.file $tmpdir/patched
+diff -q $DATA_DIR/new.file $tmpdir/patched || fail
+
+
+# --------------- cleanup ----------------------
+
+# not necessary if we're about to kill the emulator, but nice for
+# running on real devices or already-running emulators.
+run_command rm /cache/bloat*.dat $WORK_DIR/bloat.dat $CACHE_TEMP_SOURCE $WORK_DIR/old.file $WORK_DIR/patch.xdelta3 $WORK_DIR/patch.bsdiff $WORK_DIR/applypatch
+
+kill $pid_emulator
+
+rm -rf $tmpdir
+
+echo
+echo PASS
+echo
+
diff --git a/tools/applypatch/bsdiff.c b/tools/applypatch/bsdiff.c
new file mode 100644
index 0000000..f502a6b
--- /dev/null
+++ b/tools/applypatch/bsdiff.c
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+// This file is a nearly line-for-line copy of bspatch.c from the
+// bsdiff-4.3 distribution; the primary differences being how the
+// input and output data are read and the error handling.  Running
+// applypatch with the -l option will display the bsdiff license
+// notice.
+
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <bzlib.h>
+
+#include "mincrypt/sha.h"
+
+void ShowBSDiffLicense() {
+  puts("The bsdiff library used herein is:\n"
+       "\n"
+       "Copyright 2003-2005 Colin Percival\n"
+       "All rights reserved\n"
+       "\n"
+       "Redistribution and use in source and binary forms, with or without\n"
+       "modification, are permitted providing that the following conditions\n"
+       "are met:\n"
+       "1. Redistributions of source code must retain the above copyright\n"
+       "   notice, this list of conditions and the following disclaimer.\n"
+       "2. Redistributions in binary form must reproduce the above copyright\n"
+       "   notice, this list of conditions and the following disclaimer in the\n"
+       "   documentation and/or other materials provided with the distribution.\n"
+       "\n"
+       "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n"
+       "IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n"
+       "WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
+       "ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\n"
+       "DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n"
+       "DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n"
+       "OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n"
+       "HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n"
+       "STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING\n"
+       "IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
+       "POSSIBILITY OF SUCH DAMAGE.\n"
+       "\n------------------\n\n"
+       "This program uses Julian R Seward's \"libbzip2\" library, available\n"
+       "from http://www.bzip.org/.\n"
+       );
+}
+
+static off_t offtin(u_char *buf)
+{
+  off_t y;
+
+  y=buf[7]&0x7F;
+  y=y*256;y+=buf[6];
+  y=y*256;y+=buf[5];
+  y=y*256;y+=buf[4];
+  y=y*256;y+=buf[3];
+  y=y*256;y+=buf[2];
+  y=y*256;y+=buf[1];
+  y=y*256;y+=buf[0];
+
+  if(buf[7]&0x80) y=-y;
+
+  return y;
+}
+
+int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
+                     const char* patch_filename,
+                     FILE* output, SHA_CTX* ctx) {
+
+  FILE* f;
+  if ((f = fopen(patch_filename, "rb")) == NULL) {
+    fprintf(stderr, "failed to open patch file\n");
+    return 1;
+  }
+
+  // File format:
+  //   0       8       "BSDIFF40"
+  //   8       8       X
+  //   16      8       Y
+  //   24      8       sizeof(newfile)
+  //   32      X       bzip2(control block)
+  //   32+X    Y       bzip2(diff block)
+  //   32+X+Y  ???     bzip2(extra block)
+  // with control block a set of triples (x,y,z) meaning "add x bytes
+  // from oldfile to x bytes from the diff block; copy y bytes from the
+  // extra block; seek forwards in oldfile by z bytes".
+
+  unsigned char header[32];
+  if (fread(header, 1, 32, f) < 32) {
+    fprintf(stderr, "failed to read patch file header\n");
+    return 1;
+  }
+
+  if (memcmp(header, "BSDIFF40", 8) != 0) {
+    fprintf(stderr, "corrupt patch file header (magic number)\n");
+    return 1;
+  }
+
+  ssize_t ctrl_len, data_len;
+  ssize_t new_size;
+  ctrl_len = offtin(header+8);
+  data_len = offtin(header+16);
+  new_size = offtin(header+24);
+
+  if (ctrl_len < 0 || data_len < 0 || new_size < 0) {
+    fprintf(stderr, "corrupt patch file header (data lengths)\n");
+    return 1;
+  }
+
+  fclose(f);
+
+  int bzerr;
+
+#define OPEN_AT(f, bzf, offset)                                          \
+  FILE* f;                                                               \
+  BZFILE* bzf;                                                           \
+  if ((f = fopen(patch_filename, "rb")) == NULL) {                       \
+    fprintf(stderr, "failed to open patch file\n");                      \
+    return 1;                                                            \
+  }                                                                      \
+  if (fseeko(f, offset, SEEK_SET)) {                                     \
+    fprintf(stderr, "failed to seek in patch file\n");                   \
+    return 1;                                                            \
+  }                                                                      \
+  if ((bzf = BZ2_bzReadOpen(&bzerr, f, 0, 0, NULL, 0)) == NULL) {        \
+    fprintf(stderr, "failed to bzReadOpen in patch file (%d)\n", bzerr); \
+    return 1;                                                            \
+  }
+
+  OPEN_AT(cpf, cpfbz2, 32);
+  OPEN_AT(dpf, dpfbz2, 32+ctrl_len);
+  OPEN_AT(epf, epfbz2, 32+ctrl_len+data_len);
+
+#undef OPEN_AT
+
+  unsigned char* new_data = malloc(new_size);
+  if (new_data == NULL) {
+    fprintf(stderr, "failed to allocate memory for output file\n");
+    return 1;
+  }
+
+  off_t oldpos = 0, newpos = 0;
+  off_t ctrl[3];
+  off_t len_read;
+  int i;
+  unsigned char buf[8];
+  while (newpos < new_size) {
+    // Read control data
+    for (i = 0; i < 3; ++i) {
+      len_read = BZ2_bzRead(&bzerr, cpfbz2, buf, 8);
+      if (len_read < 8 || !(bzerr == BZ_OK || bzerr == BZ_STREAM_END)) {
+        fprintf(stderr, "corrupt patch (read control)\n");
+        return 1;
+      }
+      ctrl[i] = offtin(buf);
+    }
+
+    // Sanity check
+    if (newpos + ctrl[0] > new_size) {
+      fprintf(stderr, "corrupt patch (new file overrun)\n");
+      return 1;
+    }
+
+    // Read diff string
+    len_read = BZ2_bzRead(&bzerr, dpfbz2, new_data + newpos, ctrl[0]);
+    if (len_read < ctrl[0] || !(bzerr == BZ_OK || bzerr == BZ_STREAM_END)) {
+      fprintf(stderr, "corrupt patch (read diff)\n");
+      return 1;
+    }
+
+    // Add old data to diff string
+    for (i = 0; i < ctrl[0]; ++i) {
+      if ((oldpos+i >= 0) && (oldpos+i < old_size)) {
+        new_data[newpos+i] += old_data[oldpos+i];
+      }
+    }
+
+    // Adjust pointers
+    newpos += ctrl[0];
+    oldpos += ctrl[0];
+
+    // Sanity check
+    if (newpos + ctrl[1] > new_size) {
+      fprintf(stderr, "corrupt patch (new file overrun)\n");
+      return 1;
+    }
+
+    // Read extra string
+    len_read = BZ2_bzRead(&bzerr, epfbz2, new_data + newpos, ctrl[1]);
+    if (len_read < ctrl[1] || !(bzerr == BZ_OK || bzerr == BZ_STREAM_END)) {
+      fprintf(stderr, "corrupt patch (read extra)\n");
+      return 1;
+    }
+
+    // Adjust pointers
+    newpos += ctrl[1];
+    oldpos += ctrl[2];
+  }
+
+  BZ2_bzReadClose(&bzerr, cpfbz2);
+  BZ2_bzReadClose(&bzerr, dpfbz2);
+  BZ2_bzReadClose(&bzerr, epfbz2);
+  fclose(cpf);
+  fclose(dpf);
+  fclose(epf);
+
+  if (fwrite(new_data, 1, new_size, output) < new_size) {
+    fprintf(stderr, "short write of output: %d (%s)\n", errno, strerror(errno));
+    return 1;
+  }
+  SHA_update(ctx, new_data, new_size);
+  free(new_data);
+
+  return 0;
+}
diff --git a/tools/applypatch/freecache.c b/tools/applypatch/freecache.c
new file mode 100644
index 0000000..ab71b81
--- /dev/null
+++ b/tools/applypatch/freecache.c
@@ -0,0 +1,172 @@
+#include <errno.h>
+#include <libgen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <ctype.h>
+
+#include "applypatch.h"
+
+static int EliminateOpenFiles(char** files, int file_count) {
+  DIR* d;
+  struct dirent* de;
+  d = opendir("/proc");
+  if (d == NULL) {
+    fprintf(stderr, "error opening /proc: %s\n", strerror(errno));
+    return -1;
+  }
+  while ((de = readdir(d)) != 0) {
+    int i;
+    for (i = 0; de->d_name[i] != '\0' && isdigit(de->d_name[i]); ++i);
+    if (de->d_name[i]) continue;
+
+    // de->d_name[i] is numeric
+
+    char path[FILENAME_MAX];
+    strcpy(path, "/proc/");
+    strcat(path, de->d_name);
+    strcat(path, "/fd/");
+
+    DIR* fdd;
+    struct dirent* fdde;
+    fdd = opendir(path);
+    if (fdd == NULL) {
+      fprintf(stderr, "error opening %s: %s\n", path, strerror(errno));
+      continue;
+    }
+    while ((fdde = readdir(fdd)) != 0) {
+      char fd_path[FILENAME_MAX];
+      char link[FILENAME_MAX];
+      strcpy(fd_path, path);
+      strcat(fd_path, fdde->d_name);
+
+      int count;
+      count = readlink(fd_path, link, sizeof(link)-1);
+      if (count >= 0) {
+        link[count] = '\0';
+
+        // This is inefficient, but it should only matter if there are
+        // lots of files in /cache, and lots of them are open (neither
+        // of which should be true, especially in recovery).
+        if (strncmp(link, "/cache/", 7) == 0) {
+          int j;
+          for (j = 0; j < file_count; ++j) {
+            if (files[j] && strcmp(files[j], link) == 0) {
+              printf("%s is open by %s\n", link, de->d_name);
+              free(files[j]);
+              files[j] = NULL;
+            }
+          }
+        }
+      }
+    }
+    closedir(fdd);
+  }
+  closedir(d);
+
+  return 0;
+}
+
+int FindExpendableFiles(char*** names, int* entries) {
+  DIR* d;
+  struct dirent* de;
+  int size = 32;
+  *entries = 0;
+  *names = malloc(size * sizeof(char*));
+
+  char path[FILENAME_MAX];
+
+  // We're allowed to delete unopened regular files in any of these
+  // directories.
+  const char* dirs[2] = {"/cache", "/cache/recovery/otatest"};
+
+  unsigned int i;
+  for (i = 0; i < sizeof(dirs)/sizeof(dirs[0]); ++i) {
+    d = opendir(dirs[i]);
+    if (d == NULL) {
+      fprintf(stderr, "error opening %s: %s\n", dirs[i], strerror(errno));
+      continue;
+    }
+
+    // Look for regular files in the directory (not in any subdirectories).
+    while ((de = readdir(d)) != 0) {
+      strcpy(path, dirs[i]);
+      strcat(path, "/");
+      strcat(path, de->d_name);
+
+      // We can't delete CACHE_TEMP_SOURCE; if it's there we might have
+      // restarted during installation and could be depending on it to
+      // be there.
+      if (strcmp(path, CACHE_TEMP_SOURCE) == 0) continue;
+
+      struct stat st;
+      if (stat(path, &st) == 0 && S_ISREG(st.st_mode)) {
+        if (*entries >= size) {
+          size *= 2;
+          *names = realloc(*names, size * sizeof(char*));
+        }
+        (*names)[(*entries)++] = strdup(path);
+      }
+    }
+
+    closedir(d);
+  }
+
+  printf("%d regular files in deletable directories\n", *entries);
+
+  if (EliminateOpenFiles(*names, *entries) < 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+int MakeFreeSpaceOnCache(size_t bytes_needed) {
+  size_t free_now = FreeSpaceForFile("/cache");
+  printf("%ld bytes free on /cache (%ld needed)\n",
+         (long)free_now, (long)bytes_needed);
+
+  if (free_now >= bytes_needed) {
+    return 0;
+  }
+
+  char** names;
+  int entries;
+
+  if (FindExpendableFiles(&names, &entries) < 0) {
+    return -1;
+  }
+
+  if (entries == 0) {
+    // nothing we can delete to free up space!
+    fprintf(stderr, "no files can be deleted to free space on /cache\n");
+    return -1;
+  }
+
+  // We could try to be smarter about which files to delete:  the
+  // biggest ones?  the smallest ones that will free up enough space?
+  // the oldest?  the newest?
+  //
+  // Instead, we'll be dumb.
+
+  int i;
+  for (i = 0; i < entries && free_now < bytes_needed; ++i) {
+    if (names[i]) {
+      unlink(names[i]);
+      free_now = FreeSpaceForFile("/cache");
+      printf("deleted %s; now %ld bytes free\n", names[i], (long)free_now);
+      free(names[i]);
+    }
+  }
+
+  for (; i < entries; ++i) {
+    free(names[i]);
+  }
+  free(names);
+
+  return (free_now >= bytes_needed) ? 0 : -1;
+}
diff --git a/tools/applypatch/testdata/new.file b/tools/applypatch/testdata/new.file
new file mode 100644
index 0000000..cdeb8fd
--- /dev/null
+++ b/tools/applypatch/testdata/new.file
diff --git a/tools/applypatch/testdata/old.file b/tools/applypatch/testdata/old.file
new file mode 100644
index 0000000..166c873
--- /dev/null
+++ b/tools/applypatch/testdata/old.file
diff --git a/tools/applypatch/testdata/patch.bsdiff b/tools/applypatch/testdata/patch.bsdiff
new file mode 100644
index 0000000..b78d385
--- /dev/null
+++ b/tools/applypatch/testdata/patch.bsdiff
diff --git a/tools/applypatch/testdata/patch.xdelta3 b/tools/applypatch/testdata/patch.xdelta3
new file mode 100644
index 0000000..2af3ede
--- /dev/null
+++ b/tools/applypatch/testdata/patch.xdelta3
diff --git a/tools/applypatch/xdelta3.c b/tools/applypatch/xdelta3.c
new file mode 100644
index 0000000..c9a0f73
--- /dev/null
+++ b/tools/applypatch/xdelta3.c
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "xdelta3.h"
+#include "mincrypt/sha.h"
+
+int ApplyXDelta3Patch(const unsigned char* old_data, ssize_t old_size,
+                      const char* patch_filename,
+                      FILE* output, SHA_CTX* ctx) {
+#define WINDOW_SIZE 32768
+
+  int ret;
+  xd3_stream stream;
+  xd3_config config;
+
+  xd3_init_config(&config, 0);
+  config.winsize = WINDOW_SIZE;
+  ret = xd3_config_stream(&stream, &config);
+  if (ret != 0) {
+    fprintf(stderr, "xd3_config_stream error: %s\n", xd3_strerror(ret));
+    return 1;
+  }
+
+  // In xdelta3 terms, the "input" is the patch file: it contains a
+  // sequence of instruction codes and data that will be executed to
+  // produce the output file.  The "source" is the original data file;
+  // it is a blob of data to which instructions in the input may refer
+  // (eg, an instruction may say "copy such-and-such range of bytes
+  // from the source to the output").
+
+  // For simplicity, we provide the entire source to xdelta as a
+  // single block.  This means it should never have to ask us to load
+  // blocks of the source file.
+  xd3_source source;
+  source.name = "old name";
+  source.size = old_size;
+  source.ioh = NULL;
+  source.blksize = old_size;
+  source.curblkno = 0;
+  source.curblk = old_data;
+  source.onblk = old_size;
+
+  ret = xd3_set_source(&stream, &source);
+  if (ret != 0) {
+    fprintf(stderr, "xd3_set_source error: %s\n", xd3_strerror(ret));
+    return 1;
+  }
+
+  unsigned char buffer[WINDOW_SIZE];
+  FILE* input = fopen(patch_filename, "rb");
+  if (input == NULL) {
+    fprintf(stderr, "failed to open patch file %s: %d (%s)\n",
+            patch_filename, errno, strerror(errno));
+    return 1;
+  }
+
+  size_t bytes_read;
+
+  do {
+    bytes_read = fread(buffer, 1, WINDOW_SIZE, input);
+    if (feof(input)) {
+      xd3_set_flags(&stream, XD3_FLUSH);
+    }
+    xd3_avail_input(&stream, buffer, bytes_read);
+ process:
+    ret = xd3_decode_input(&stream);
+    switch (ret) {
+      case XD3_INPUT:
+        continue;
+      case XD3_OUTPUT:
+        SHA_update(ctx, stream.next_out, stream.avail_out);
+        if (fwrite(stream.next_out, 1, stream.avail_out, output) !=
+            stream.avail_out) {
+          fprintf(stderr, "short write of output file: %d (%s)\n",
+                  errno, strerror(errno));
+          return 1;
+        }
+        xd3_consume_output(&stream);
+        goto process;
+      case XD3_GETSRCBLK:
+        // We provided the entire source file already; it should never
+        // have to ask us for a block.
+        fprintf(stderr, "xd3_decode_input: unexpected GETSRCBLK\n");
+        return 1;
+      case XD3_GOTHEADER:
+      case XD3_WINSTART:
+      case XD3_WINFINISH:
+        // These are informational events we don't care about.
+        goto process;
+      default:
+        fprintf(stderr, "xd3_decode_input: unknown error %s (%s)\n",
+                xd3_strerror(ret), stream.msg);
+        return 1;
+    }
+  } while (!feof(input));
+
+  fclose(input);
+  return 0;
+
+#undef WINDOW_SIZE
+}
diff --git a/tools/buildinfo.sh b/tools/buildinfo.sh
index 5addfb6..5069e45 100755
--- a/tools/buildinfo.sh
+++ b/tools/buildinfo.sh
@@ -21,6 +21,7 @@ echo "ro.product.board=$TARGET_BOOTLOADER_BOARD_NAME"
 echo "ro.product.manufacturer=$PRODUCT_MANUFACTURER"
 echo "ro.product.locale.language=$PRODUCT_DEFAULT_LANGUAGE"
 echo "ro.product.locale.region=$PRODUCT_DEFAULT_REGION"
+echo "ro.board.platform=$TARGET_BOARD_PLATFORM"
 
 echo "# ro.build.product is obsolete; use ro.product.device"
 echo "ro.build.product=$TARGET_DEVICE"
diff --git a/tools/check_prereq/Android.mk b/tools/check_prereq/Android.mk
new file mode 100644
index 0000000..abedff6
--- /dev/null
+++ b/tools/check_prereq/Android.mk
@@ -0,0 +1,30 @@
+# Copyright (C) 2009 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.
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+ifneq ($(TARGET_SIMULATOR),true)
+
+LOCAL_SRC_FILES := check_prereq.c
+LOCAL_MODULE := check_prereq
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+LOCAL_MODULE_TAGS := eng
+LOCAL_C_INCLUDES +=
+LOCAL_STATIC_LIBRARIES += libcutils libc
+
+include $(BUILD_EXECUTABLE)
+
+endif  # !TARGET_SIMULATOR
+
diff --git a/tools/check_prereq/check_prereq.c b/tools/check_prereq/check_prereq.c
new file mode 100644
index 0000000..d7b8918
--- /dev/null
+++ b/tools/check_prereq/check_prereq.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2009 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.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/system_properties.h>
+#include <cutils/properties.h>
+
+// Compare the timestamp of the new build (passed on the command line)
+// against the current value of ro.build.date.utc.  Exit successfully
+// if the new build is newer than the current build (or if the
+// timestamps are the same).
+int main(int argc, char** argv) {
+  if (argc != 2) {
+ usage:
+    fprintf(stderr, "usage: %s <timestamp>\n", argv[0]);
+    return 2;
+  }
+
+  char value[PROPERTY_VALUE_MAX];
+  char* default_value = "0";
+
+  property_get("ro.build.date.utc", value, default_value);
+
+  long current = strtol(value, NULL, 10);
+  char* end;
+  long install = strtol(argv[1], &end, 10);
+
+  printf("current build time: [%ld]  new build time: [%ld]\n",
+         current, install);
+
+  return (*end == 0 && current > 0 && install >= current) ? 0 : 1;
+}
diff --git a/tools/droiddoc/src/Stubs.java b/tools/droiddoc/src/Stubs.java
index 806498b..e1ec76a 100644
--- a/tools/droiddoc/src/Stubs.java
+++ b/tools/droiddoc/src/Stubs.java
@@ -26,7 +26,7 @@ import java.io.FileNotFoundException;
 import java.io.PrintStream;
 
 public class Stubs {
-    private static HashSet<ClassInfo> notStrippable;  
+    private static HashSet<ClassInfo> notStrippable;
     public static void writeStubs(String stubsDir, Boolean writeXML, String xmlFile,
             HashSet<String> stubPackages) {
         // figure out which classes we need
@@ -90,7 +90,7 @@ public class Stubs {
                         }
                     }
                 }
-                
+
                 // annotations are handled like methods
                 methods = cl.annotationElements();
                 for (MethodInfo m: methods) {
@@ -156,14 +156,14 @@ public class Stubs {
     }
 
     public static void cantStripThis(ClassInfo cl, HashSet<ClassInfo> notStrippable, String why) {
-      
+
       if (!notStrippable.add(cl)) {
         // slight optimization: if it already contains cl, it already contains
         // all of cl's parents
           return;
       }
       cl.setReasonIncluded(why);
-      
+
       // cant strip annotations
       /*if (cl.annotations() != null){
           for (AnnotationInstanceInfo ai : cl.annotations()){
@@ -233,7 +233,7 @@ public class Stubs {
           }
       }
     }
-    
+
     private static void cantStripThis(MethodInfo[] mInfos , HashSet<ClassInfo> notStrippable) {
       //for each method, blow open the parameters, throws and return types.  also blow open their generics
       if (mInfos != null){
@@ -241,8 +241,8 @@ public class Stubs {
               if (mInfo.getTypeParameters() != null){
                   for (TypeInfo tInfo : mInfo.getTypeParameters()){
                       if (tInfo.asClassInfo() != null){
-                          cantStripThis(tInfo.asClassInfo(), notStrippable, "8:" + 
-                                        mInfo.realContainingClass().qualifiedName() + ":" + 
+                          cantStripThis(tInfo.asClassInfo(), notStrippable, "8:" +
+                                        mInfo.realContainingClass().qualifiedName() + ":" +
                                         mInfo.name());
                       }
                   }
@@ -250,8 +250,8 @@ public class Stubs {
               if (mInfo.parameters() != null){
                   for (ParameterInfo pInfo : mInfo.parameters()){
                       if (pInfo.type() != null && pInfo.type().asClassInfo() != null){
-                          cantStripThis(pInfo.type().asClassInfo(), notStrippable, 
-                                        "9:"+  mInfo.realContainingClass().qualifiedName() 
+                          cantStripThis(pInfo.type().asClassInfo(), notStrippable,
+                                        "9:"+  mInfo.realContainingClass().qualifiedName()
                                         + ":" + mInfo.name());
                           if (pInfo.type().typeArguments() != null){
                               for (TypeInfo tInfoType : pInfo.type().typeArguments()){
@@ -264,9 +264,9 @@ public class Stubs {
                                                   + mInfo.containingClass().qualifiedName()
                                                   + '.' + mInfo.name() + "()");
                                       } else {
-                                          cantStripThis(tcl, notStrippable, 
-                                                  "10:" +  
-                                                  mInfo.realContainingClass().qualifiedName() + ":" + 
+                                          cantStripThis(tcl, notStrippable,
+                                                  "10:" +
+                                                  mInfo.realContainingClass().qualifiedName() + ":" +
                                                   mInfo.name());
                                       }
                                   }
@@ -276,19 +276,19 @@ public class Stubs {
                   }
               }
               for (ClassInfo thrown : mInfo.thrownExceptions()){
-                  cantStripThis(thrown, notStrippable, "11:" + 
+                  cantStripThis(thrown, notStrippable, "11:" +
                                 mInfo.realContainingClass().qualifiedName()
                                 +":" + mInfo.name());
               }
               if (mInfo.returnType() != null && mInfo.returnType().asClassInfo() != null){
-                  cantStripThis(mInfo.returnType().asClassInfo(), notStrippable, 
-                                "12:" + mInfo.realContainingClass().qualifiedName() + 
+                  cantStripThis(mInfo.returnType().asClassInfo(), notStrippable,
+                                "12:" + mInfo.realContainingClass().qualifiedName() +
                                 ":" + mInfo.name());
                   if (mInfo.returnType().typeArguments() != null){
                       for (TypeInfo tyInfo: mInfo.returnType().typeArguments() ){
                           if (tyInfo.asClassInfo() != null){
-                              cantStripThis(tyInfo.asClassInfo(), notStrippable, 
-                                            "13:" + 
+                              cantStripThis(tyInfo.asClassInfo(), notStrippable,
+                                            "13:" +
                                             mInfo.realContainingClass().qualifiedName()
                                             + ":" + mInfo.name());
                           }
@@ -417,18 +417,18 @@ public class Stubs {
 
         for (ClassInfo inner: cl.getRealInnerClasses()) {
             if (notStrippable.contains(inner)
-                    && !inner.isDocOnly()){  
+                    && !inner.isDocOnly()){
                 writeClass(stream, inner);
             }
         }
 
-        
+
         for (MethodInfo method: cl.constructors()) {
             if (!method.isDocOnly()) {
                 writeMethod(stream, method, true);
             }
         }
-        
+
         boolean fieldNeedsInitialization = false;
         boolean staticFieldNeedsInitialization = false;
         for (FieldInfo field: cl.allSelfFields()) {
@@ -441,12 +441,12 @@ public class Stubs {
                 }
             }
         }
-        
-        // The compiler includes a default public constructor that calls the super classes 
-        // default constructor in the case where there are no written constructors.  
+
+        // The compiler includes a default public constructor that calls the super classes
+        // default constructor in the case where there are no written constructors.
         // So, if we hide all the constructors, java may put in a constructor
-        // that calls a nonexistent super class constructor.  So, if there are no constructors, 
-        // and the super class doesn't have a default constructor, write in a private constructor 
+        // that calls a nonexistent super class constructor.  So, if there are no constructors,
+        // and the super class doesn't have a default constructor, write in a private constructor
         // that works.  TODO -- we generate this as protected, but we really should generate
         // it as private unless it also exists in the real code.
         if ((cl.constructors().length == 0 && (cl.getNonWrittenConstructors().length != 0
@@ -454,7 +454,7 @@ public class Stubs {
                 && !cl.isAnnotation()
                 && !cl.isInterface()
                 && !cl.isEnum() ) {
-            //Errors.error(Errors.HIDDEN_CONSTRUCTOR, 
+            //Errors.error(Errors.HIDDEN_CONSTRUCTOR,
             //             cl.position(), "No constructors " +
             //            "found and superclass has no parameterless constructor.  A constructor " +
             //            "that calls an appropriate superclass constructor " +
@@ -463,7 +463,7 @@ public class Stubs {
                     + "() { " + superCtorCall(cl,null)
                     + "throw new" + " RuntimeException(\"Stub!\"); }");
         }
-        
+
         for (MethodInfo method: cl.allSelfMethods()) {
             if (cl.isEnum()) {
                 if (("values".equals(method.name())
@@ -484,11 +484,11 @@ public class Stubs {
         //These can't be hidden.
         for (MethodInfo method : cl.getHiddenMethods()){
             MethodInfo overriddenMethod = method.findRealOverriddenMethod(method.name(), method.signature(), notStrippable);
-            ClassInfo classContainingMethod = method.findRealOverriddenClass(method.name(), 
+            ClassInfo classContainingMethod = method.findRealOverriddenClass(method.name(),
                                                                              method.signature());
             if (overriddenMethod != null && !overriddenMethod.isHidden()
                 && !overriddenMethod.isDocOnly() &&
-                (overriddenMethod.isAbstract() || 
+                (overriddenMethod.isAbstract() ||
                 overriddenMethod.containingClass().isInterface())) {
                 method.setReason("1:" + classContainingMethod.qualifiedName());
                 cl.addMethod(method);
@@ -519,11 +519,11 @@ public class Stubs {
             }
             stream.println("}");
         }
-        
+
         stream.println("}");
     }
 
-    
+
     static void writeMethod(PrintStream stream, MethodInfo method, boolean isConstructor) {
         String comma;
 
@@ -627,7 +627,7 @@ public class Stubs {
         if (mi.isAbstract() || mi.isStatic() || mi.isFinal()) {
             return false;
         }
-        
+
         // Find any relevant ancestor declaration and inspect it
         MethodInfo om = mi.findSuperclassImplementation(notStrippable);
         if (om != null) {
@@ -735,8 +735,8 @@ public class Stubs {
                     //put null in each super class method.  Cast null to the correct type
                     //to avoid collisions with other constructors.  If the type is generic
                     //don't cast it
-                    result += (!t.isTypeVariable() ? "(" + t.qualifiedTypeName() + t.dimension() +  
-                              ")" : "") + "null"; 
+                    result += (!t.isTypeVariable() ? "(" + t.qualifiedTypeName() + t.dimension() +
+                              ")" : "") + "null";
                 }
                 if (i != N-1) {
                     result += ",";
@@ -769,8 +769,8 @@ public class Stubs {
         }
         stream.println(";");
     }
-    
-    static void writeXML(PrintStream xmlWriter, HashMap<PackageInfo, List<ClassInfo>> allClasses, 
+
+    static void writeXML(PrintStream xmlWriter, HashMap<PackageInfo, List<ClassInfo>> allClasses,
                          HashSet notStrippable) {
         // extract the set of packages, sort them by name, and write them out in that order
         Set<PackageInfo> allClassKeys = allClasses.keySet();
@@ -783,22 +783,22 @@ public class Stubs {
         }
         xmlWriter.println("</api>");
     }
-    
+
     static void writePackageXML(PrintStream xmlWriter, PackageInfo pack, List<ClassInfo> classList,
                                 HashSet notStrippable) {
         ClassInfo[] classes = classList.toArray(new ClassInfo[classList.size()]);
         Arrays.sort(classes, ClassInfo.comparator);
         xmlWriter.println("<package name=\"" + pack.name() + "\"\n"
-                //+ " source=\"" + pack.position() + "\"\n" 
+                //+ " source=\"" + pack.position() + "\"\n"
                 + ">");
         for (ClassInfo cl : classes) {
             writeClassXML(xmlWriter, cl, notStrippable);
         }
         xmlWriter.println("</package>");
-      
-      
+
+
     }
-    
+
     static void writeClassXML(PrintStream xmlWriter, ClassInfo cl, HashSet notStrippable) {
         String scope = DroidDoc.scope(cl);
         String deprecatedString = "";
@@ -821,7 +821,7 @@ public class Stubs {
                 + " visibility=\"" + scope + "\"\n"
                 //+ " source=\"" + cl.position() + "\"\n"
                 + ">");
-        
+
         ClassInfo[] interfaces = cl.realInterfaces();
         Arrays.sort(interfaces, ClassInfo.comparator);
         for (ClassInfo iface : interfaces) {
@@ -830,13 +830,13 @@ public class Stubs {
                 xmlWriter.println("</implements>");
             }
         }
-        
+
         MethodInfo[] constructors = cl.constructors();
         Arrays.sort(constructors, MethodInfo.comparator);
         for (MethodInfo mi : constructors) {
             writeConstructorXML(xmlWriter, mi);
         }
-       
+
         MethodInfo[] methods = cl.allSelfMethods();
         Arrays.sort(methods, MethodInfo.comparator);
         for (MethodInfo mi : methods) {
@@ -844,16 +844,16 @@ public class Stubs {
                 writeMethodXML(xmlWriter, mi);
             }
         }
-       
+
         FieldInfo[] fields = cl.allSelfFields();
         Arrays.sort(fields, FieldInfo.comparator);
         for (FieldInfo fi : fields) {
             writeFieldXML(xmlWriter, fi);
         }
         xmlWriter.println("</" + declString + ">");
-        
+
     }
-    
+
     static void writeMethodXML(PrintStream xmlWriter, MethodInfo mi) {
         String scope = DroidDoc.scope(mi);
 
@@ -863,10 +863,10 @@ public class Stubs {
         } else {
             deprecatedString = "not deprecated";
         }
-        xmlWriter.println("<method name=\"" + mi.name() + "\"\n" 
+        xmlWriter.println("<method name=\"" + mi.name() + "\"\n"
                 + ((mi.returnType() != null)
                         ? " return=\"" + makeXMLcompliant(fullParameterTypeName(mi, mi.returnType(), false)) + "\"\n"
-                        : "") 
+                        : "")
                 + " abstract=\"" + mi.isAbstract() + "\"\n"
                 + " native=\"" + mi.isNative() + "\"\n"
                 + " synchronized=\"" + mi.isSynchronized() + "\"\n"
@@ -884,7 +884,7 @@ public class Stubs {
             count++;
             writeParameterXML(xmlWriter, mi, pi, count == numParameters);
         }
-        
+
         // but write exceptions in canonicalized order
         ClassInfo[] exceptions = mi.thrownExceptions();
         Arrays.sort(exceptions, ClassInfo.comparator);
@@ -895,7 +895,7 @@ public class Stubs {
         }
         xmlWriter.println("</method>");
     }
-    
+
     static void writeConstructorXML(PrintStream xmlWriter, MethodInfo mi) {
         String scope = DroidDoc.scope(mi);
         String deprecatedString = "";
@@ -919,7 +919,7 @@ public class Stubs {
             count++;
             writeParameterXML(xmlWriter, mi, pi, count == numParameters);
         }
-        
+
         ClassInfo[] exceptions = mi.thrownExceptions();
         Arrays.sort(exceptions, ClassInfo.comparator);
         for (ClassInfo pi : exceptions) {
@@ -929,14 +929,14 @@ public class Stubs {
         }
         xmlWriter.println("</constructor>");
   }
-    
+
     static void writeParameterXML(PrintStream xmlWriter, MethodInfo method,
             ParameterInfo pi, boolean isLast) {
         xmlWriter.println("<parameter name=\"" + pi.name() + "\" type=\"" +
                 makeXMLcompliant(fullParameterTypeName(method, pi.type(), isLast)) + "\">");
         xmlWriter.println("</parameter>");
     }
-    
+
     static void writeFieldXML(PrintStream xmlWriter, FieldInfo fi) {
         String scope = DroidDoc.scope(fi);
         String deprecatedString = "";
@@ -955,7 +955,7 @@ public class Stubs {
                           + " type=\"" + fullTypeName + "\"\n"
                           + " transient=\"" + fi.isTransient() + "\"\n"
                           + " volatile=\"" + fi.isVolatile() + "\"\n"
-                          + (fieldIsInitialized(fi) ? " value=\"" + value + "\"\n" : "") 
+                          + (fieldIsInitialized(fi) ? " value=\"" + value + "\"\n" : "")
                           + " static=\"" + fi.isStatic() + "\"\n"
                           + " final=\"" + fi.isFinal() + "\"\n"
                           + " deprecated=\"" + deprecatedString + "\"\n"
@@ -964,7 +964,7 @@ public class Stubs {
                           + ">");
         xmlWriter.println("</field>");
     }
-    
+
     static String makeXMLcompliant(String s) {
         String returnString = "";
         returnString = s.replaceAll("&", "&amp;");
@@ -974,16 +974,15 @@ public class Stubs {
         returnString = returnString.replaceAll("'", "&pos;");
         return returnString;
     }
-    
+
     static String fullParameterTypeName(MethodInfo method, TypeInfo type, boolean isLast) {
         String fullTypeName = type.fullName(method.typeVariables());
         if (isLast && method.isVarArgs()) {
             // TODO: note that this does not attempt to handle hypothetical
             // vararg methods whose last parameter is a list of arrays, e.g.
             // "Object[]...".
-            fullTypeName = type.qualifiedTypeName() + "...";
+            fullTypeName = type.fullNameNoDimension(method.typeVariables()) + "...";
         }
         return fullTypeName;
     }
 }
-
diff --git a/tools/droiddoc/src/TypeInfo.java b/tools/droiddoc/src/TypeInfo.java
index 68cdd8e..c1119de 100644
--- a/tools/droiddoc/src/TypeInfo.java
+++ b/tools/droiddoc/src/TypeInfo.java
@@ -81,37 +81,43 @@ public class TypeInfo
 
     public String fullName(HashSet<String> typeVars)
     {
+        mFullName = fullNameNoDimension(typeVars) + mDimension;
+        return mFullName;
+    }
+
+    public String fullNameNoDimension(HashSet<String> typeVars)
+    {
+        String fullName = null;
         if (mIsTypeVariable) {
             if (typeVars.contains(mQualifiedTypeName)) {
                 // don't recurse forever with the parameters.  This handles
                 // Enum<K extends Enum<K>>
-                return mQualifiedTypeName + mDimension;
+                return mQualifiedTypeName;
             }
             typeVars.add(mQualifiedTypeName);
         }
 /*
-        if (mFullName != null) {
-            return mFullName;
+        if (fullName != null) {
+            return fullName;
         }
 */
-        mFullName = mQualifiedTypeName;
+        fullName = mQualifiedTypeName;
         if (mTypeArguments != null && mTypeArguments.length > 0) {
-            mFullName += typeArgumentsName(mTypeArguments, typeVars);
+            fullName += typeArgumentsName(mTypeArguments, typeVars);
         }
         else if (mSuperBounds != null && mSuperBounds.length > 0) {
-            mFullName += " super " + mSuperBounds[0].fullName(typeVars);
+            fullName += " super " + mSuperBounds[0].fullName(typeVars);
             for (int i=1; i<mSuperBounds.length; i++) {
-                mFullName += " & " + mSuperBounds[i].fullName(typeVars);
+                fullName += " & " + mSuperBounds[i].fullName(typeVars);
             }
         }
         else if (mExtendsBounds != null && mExtendsBounds.length > 0) {
-            mFullName += " extends " + mExtendsBounds[0].fullName(typeVars);
+            fullName += " extends " + mExtendsBounds[0].fullName(typeVars);
             for (int i=1; i<mExtendsBounds.length; i++) {
-                mFullName += " & " + mExtendsBounds[i].fullName(typeVars);
+                fullName += " & " + mExtendsBounds[i].fullName(typeVars);
             }
         }
-        mFullName += mDimension;
-        return mFullName;
+        return fullName;
     }
 
     public TypeInfo[] typeArguments()
@@ -241,13 +247,13 @@ public class TypeInfo
             return "null";
         }
     }
-    
+
     public String toString(){
       String returnString = "";
       returnString += "Primitive?: " + mIsPrimitive + " TypeVariable?: " +
       mIsTypeVariable + " Wildcard?: " + mIsWildcard + " Dimension: " + mDimension
       + " QualifedTypeName: " + mQualifiedTypeName;
-      
+
       if (mTypeArguments != null){
         returnString += "\nTypeArguments: ";
         for (TypeInfo tA : mTypeArguments){
diff --git a/tools/fs_config/Android.mk b/tools/fs_config/Android.mk
new file mode 100644
index 0000000..3f2ed95
--- /dev/null
+++ b/tools/fs_config/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+ifneq ($(TARGET_SIMULATOR),true)
+
+LOCAL_SRC_FILES := fs_config.c
+LOCAL_MODULE := fs_config
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+LOCAL_MODULE_TAGS := eng
+
+include $(BUILD_HOST_EXECUTABLE)
+
+endif  # !TARGET_SIMULATOR
diff --git a/tools/fs_config/fs_config.c b/tools/fs_config/fs_config.c
new file mode 100644
index 0000000..5b99b30
--- /dev/null
+++ b/tools/fs_config/fs_config.c
@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "private/android_filesystem_config.h"
+
+// This program takes a list of files and directories (indicated by a
+// trailing slash) on the stdin, and prints to stdout each input
+// filename along with its desired uid, gid, and mode (in octal).
+// The leading slash should be stripped from the input.
+//
+// Example input:
+//
+//    system/etc/dbus.conf
+//    data/app/
+//
+// Output:
+//
+//    system/etc/dbus.conf 1002 1002 440
+//    data/app 1000 1000 771
+//
+// Note that the output will omit the trailing slash from
+// directories.
+
+int main(int argc, char** argv) {
+  char buffer[1024];
+
+  while (fgets(buffer, 1023, stdin) != NULL) {
+    int is_dir = 0;
+    int i;
+    for (i = 0; i < 1024 && buffer[i]; ++i) {
+      switch (buffer[i]) {
+        case '\n':
+          buffer[i-is_dir] = '\0';
+          i = 1025;
+          break;
+        case '/':
+          is_dir = 1;
+          break;
+        default:
+          is_dir = 0;
+          break;
+      }
+    }
+
+    unsigned uid = 0, gid = 0, mode = 0;
+    fs_config(buffer, is_dir, &uid, &gid, &mode);
+    printf("%s %d %d %o\n", buffer, uid, gid, mode);
+  }
+  return 0;
+}
diff --git a/tools/rgb2565/to565.c b/tools/rgb2565/to565.c
index 01d14aa..abf9cdb 100644
--- a/tools/rgb2565/to565.c
+++ b/tools/rgb2565/to565.c
@@ -13,20 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-	      
+	
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
 
-#define to565(r,g,b) \
+#define to565(r,g,b)                                            \
     ((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3))
 
+#define from565_r(x) ((((x) >> 11) & 0x1f) * 255 / 31)
+#define from565_g(x) ((((x) >> 5) & 0x3f) * 255 / 63)
+#define from565_b(x) (((x) & 0x1f) * 255 / 31)
+
 void to_565_raw(void)
 {
     unsigned char in[3];
     unsigned short out;
-    
+
     while(read(0, in, 3) == 3) {
         out = to565(in[0],in[1],in[2]);
         write(1, &out, 2);
@@ -34,6 +38,66 @@ void to_565_raw(void)
     return;
 }
 
+void to_565_raw_dither(int width)
+{
+    unsigned char in[3];
+    unsigned short out;
+    int i = 0;
+    int e;
+
+    int* error = malloc((width+2) * 3 * sizeof(int));
+    int* next_error = malloc((width+2) * 3 * sizeof(int));
+    memset(error, 0, (width+2) * 3 * sizeof(int));
+    memset(next_error, 0, (width+2) * 3 * sizeof(int));
+    error += 3;        // array goes from [-3..((width+1)*3+2)]
+    next_error += 3;
+
+    while(read(0, in, 3) == 3) {
+        int r = in[0] + error[i*3+0];
+        int rb = (r < 0) ? 0 : ((r > 255) ? 255 : r);
+
+        int g = in[1] + error[i*3+1];
+        int gb = (g < 0) ? 0 : ((g > 255) ? 255 : g);
+
+        int b = in[2] + error[i*3+2];
+        int bb = (b < 0) ? 0 : ((b > 255) ? 255 : b);
+
+        out = to565(rb, gb, bb);
+        write(1, &out, 2);
+
+#define apply_error(ch) {                                               \
+            next_error[(i-1)*3+ch] += e * 3 / 16;                       \
+            next_error[(i)*3+ch] += e * 5 / 16;                         \
+            next_error[(i+1)*3+ch] += e * 1 / 16;                       \
+            error[(i+1)*3+ch] += e - ((e*1/16) + (e*3/16) + (e*5/16));  \
+        }
+
+        e = r - from565_r(out);
+        apply_error(0);
+
+        e = g - from565_g(out);
+        apply_error(1);
+
+        e = b - from565_b(out);
+        apply_error(2);
+
+#undef apply_error
+
+        ++i;
+        if (i == width) {
+            // error <- next_error; next_error <- 0
+            int* temp = error; error = next_error; next_error = temp;
+            memset(next_error, 0, (width+1) * 3 * sizeof(int));
+            i = 0;
+        }
+    }
+
+    free(error-3);
+    free(next_error-3);
+
+    return;
+}
+
 void to_565_rle(void)
 {
     unsigned char in[3];
@@ -66,10 +130,14 @@ void to_565_rle(void)
 
 int main(int argc, char **argv)
 {
-    if ((argc > 1) && (!strcmp(argv[1],"-rle"))) {
+    if ((argc == 2) && (!strcmp(argv[1],"-rle"))) {
         to_565_rle();
     } else {
-        to_565_raw();
+        if (argc > 2 && (!strcmp(argv[1], "-w"))) {
+            to_565_raw_dither(atoi(argv[2]));
+        } else {
+            to_565_raw();
+        }
     }
     return 0;
 }