merge with eclair recovery

Author: koush

Android.mk

@@ -8,26 +8,44 @@ commands_recovery_local_path := $(LOCAL_PATH)
 # LOCAL_CPP_EXTENSION := .c
 
 LOCAL_SRC_FILES := \
-    extendedcommands.c \
-    nandroid.c \
-    legacy.c \
-    commands.c \
-    recovery.c \
-    bootloader.c \
-    firmware.c \
-    install.c \
-    roots.c \
-    ui.c \
-    verifier.c
+	extendedcommands.c \
+	nandroid.c \
+	legacy.c \
+	commands.c \
+	recovery.c \
+	install.c \
+	roots.c \
+	ui.c \
+	verifier.c
+
+LOCAL_SRC_FILES += \
+    reboot.c \
+    setprop.c
+
+ifndef BOARD_HAS_NO_MISC_PARTITION
+    LOCAL_SRC_FILES += \
+        firmware.c \
+        bootloader.c
+else
+    LOCAL_CFLAGS += -DBOARD_HAS_NO_MISC_PARTITION
+endif
+
+ifdef BOARD_RECOVERY_IGNORE_BOOTABLES
+    LOCAL_CFLAGS += -DBOARD_RECOVERY_IGNORE_BOOTABLES
+endif
+
+ifdef BOARD_HIJACK_RECOVERY_PATH
+    LOCAL_CFLAGS += -DBOARD_HIJACK_RECOVERY_PATH=\"$(BOARD_HIJACK_RECOVERY_PATH)\"
+endif
 
 LOCAL_SRC_FILES += test_roots.c
 
 LOCAL_MODULE := recovery
 
 LOCAL_FORCE_STATIC_EXECUTABLE := true
 
-RECOVERY_VERSION := ClockworkMod Recovery v2.5.0.1
-LOCAL_CFLAGS := -DRECOVERY_VERSION="$(RECOVERY_VERSION)"
+RECOVERY_VERSION := ClockworkMod Recovery v2.5.0.8
+LOCAL_CFLAGS += -DRECOVERY_VERSION="$(RECOVERY_VERSION)"
 RECOVERY_API_VERSION := 3
 LOCAL_CFLAGS += -DRECOVERY_API_VERSION=$(RECOVERY_API_VERSION)
 
@@ -59,6 +77,14 @@ ifdef BOARD_DATA_FILESYSTEM
   LOCAL_CFLAGS += -DDATA_FILESYSTEM=\"$(BOARD_DATA_FILESYSTEM)\"
 endif
 
+ifdef BOARD_DATADATA_DEVICE
+  LOCAL_CFLAGS += -DDATADATA_DEVICE=\"$(BOARD_DATADATA_DEVICE)\"
+endif
+
+ifdef BOARD_DATADATA_FILESYSTEM
+  LOCAL_CFLAGS += -DDATADATA_FILESYSTEM=\"$(BOARD_DATADATA_FILESYSTEM)\"
+endif
+
 ifdef BOARD_CACHE_DEVICE
   LOCAL_CFLAGS += -DCACHE_DEVICE=\"$(BOARD_CACHE_DEVICE)\"
 endif
@@ -67,10 +93,38 @@ ifdef BOARD_CACHE_FILESYSTEM
   LOCAL_CFLAGS += -DCACHE_FILESYSTEM=\"$(BOARD_CACHE_FILESYSTEM)\"
 endif
 
+ifdef BOARD_SYSTEM_DEVICE
+  LOCAL_CFLAGS += -DSYSTEM_DEVICE=\"$(BOARD_SYSTEM_DEVICE)\"
+endif
+
+ifdef BOARD_SYSTEM_FILESYSTEM
+  LOCAL_CFLAGS += -DSYSTEM_FILESYSTEM=\"$(BOARD_SYSTEM_FILESYSTEM)\"
+endif
+
 ifdef BOARD_HAS_DATADATA
   LOCAL_CFLAGS += -DHAS_DATADATA
 endif
 
+ifdef BOARD_DATA_FILESYSTEM_OPTIONS
+  LOCAL_CFLAGS += -DDATA_FILESYSTEM_OPTIONS=\"$(BOARD_DATA_FILESYSTEM_OPTIONS)\"
+endif
+
+ifdef BOARD_DATADATA_FILESYSTEM_OPTIONS
+  LOCAL_CFLAGS += -DDATADATA_FILESYSTEM_OPTIONS=\"$(BOARD_DATADATA_FILESYSTEM_OPTIONS)\"
+endif
+
+ifdef BOARD_CACHE_FILESYSTEM_OPTIONS
+  LOCAL_CFLAGS += -DCACHE_FILESYSTEM_OPTIONS=\"$(BOARD_CACHE_FILESYSTEM_OPTIONS)\"
+endif
+
+ifdef BOARD_SYSTEM_FILESYSTEM_OPTIONS
+  LOCAL_CFLAGS += -DSYSTEM_FILESYSTEM_OPTIONS=\"$(BOARD_SYSTEM_FILESYSTEM_OPTIONS)\"
+endif
+
+ifdef BOARD_HAS_MTD_CACHE
+  LOCAL_CFLAGS += -DBOARD_HAS_MTD_CACHE
+endif
+
 # This binary is in the recovery ramdisk, which is otherwise a copy of root.
 # It gets copied there in config/Makefile.  LOCAL_MODULE_TAGS suppresses
 # a (redundant) copy of the binary in /system/bin for user builds.
@@ -93,7 +147,8 @@ LOCAL_STATIC_LIBRARIES += libstdc++ libc
 
 include $(BUILD_EXECUTABLE)
 
-RECOVERY_LINKS := amend busybox flash_image dump_image mkyaffs2image unyaffs erase_image nandroid
+RECOVERY_LINKS := amend busybox flash_image dump_image mkyaffs2image unyaffs erase_image nandroid reboot
+
 # nc is provided by external/netcat
 SYMLINKS := $(addprefix $(TARGET_RECOVERY_ROOT_OUT)/sbin/,$(RECOVERY_LINKS))
 $(SYMLINKS): RECOVERY_BINARY := $(LOCAL_MODULE)
@@ -156,6 +211,7 @@ include $(commands_recovery_local_path)/tools/Android.mk
 include $(commands_recovery_local_path)/edify/Android.mk
 include $(commands_recovery_local_path)/updater/Android.mk
 include $(commands_recovery_local_path)/applypatch/Android.mk
+include $(commands_recovery_local_path)/utilities/Android.mk
 commands_recovery_local_path :=
 
 endif   # TARGET_ARCH == arm

commands.c

@@ -626,11 +626,13 @@ cmd_write_firmware_image(const char *name, void *cookie,
         return 1;
     }
 
+#ifndef BOARD_HAS_NO_MISC_PARTITION
     if (remember_firmware_update(type, context.data, context.total_bytes)) {
         LOGE("Can't store %s image\n", type);
         free(context.data);
         return 1;
     }
+#endif
 
     return 0;
 }

default_recovery_ui.c

@@ -27,8 +27,8 @@ char* MENU_ITEMS[] = { "reboot system now",
                        "wipe data/factory reset",
                        "wipe cache partition",
                        "install zip from sdcard",
-                       "nandroid",
-                       "partitions menu",
+                       "backup and restore",
+                       "mounts and storage",
                        "advanced",
                        NULL };
 
@@ -54,10 +54,12 @@ int device_reboot_now(volatile char* key_pressed, int key_code) {
 int device_handle_key(int key_code, int visible) {
     if (visible) {
         switch (key_code) {
+            case KEY_CAPSLOCK:
             case KEY_DOWN:
             case KEY_VOLUMEDOWN:
                 return HIGHLIGHT_DOWN;
 
+            case KEY_LEFTSHIFT:
             case KEY_UP:
             case KEY_VOLUMEUP:
                 return HIGHLIGHT_UP;
@@ -69,6 +71,7 @@ int device_handle_key(int key_code, int visible) {
                 if (!get_allow_toggle_display())
                     return GO_BACK;
                 break;
+            case KEY_LEFTBRACE:
             case KEY_ENTER:
             case BTN_MOUSE:
             case KEY_CENTER:

extendedcommands.c

@@ -61,17 +61,21 @@ void toggle_script_asserts()
 int install_zip(const char* packagefilepath)
 {
     ui_print("\n-- Installing: %s\n", packagefilepath);
+#ifndef BOARD_HAS_NO_MISC_PARTITION
     set_sdcard_update_bootloader_message();
+#endif
     int status = install_package(packagefilepath);
     ui_reset_progress();
     if (status != INSTALL_SUCCESS) {
         ui_set_background(BACKGROUND_ICON_ERROR);
         ui_print("Installation aborted.\n");
         return 1;
     } 
+#ifndef BOARD_HAS_NO_MISC_PARTITION
     if (firmware_update_pending()) {
         ui_print("\nReboot via menu to complete\ninstallation.\n");
     }
+#endif
     ui_set_background(BACKGROUND_ICON_NONE);
     ui_print("\nInstall from sdcard complete.\n");
     return 0;
@@ -414,6 +418,10 @@ void show_mount_usb_storage_menu()
 
 int confirm_selection(const char* title, const char* confirm)
 {
+    struct stat info;
+    if (0 == stat("/sdcard/clockworkmod/.no_confirm", &info))
+        return 1;
+
     char* confirm_headers[]  = {  title, "  THIS CAN NOT BE UNDONE.", "", NULL };
     char* items[] = { "No",
                       "No",
@@ -470,7 +478,7 @@ int format_non_mtd_device(const char* root)
 
 void show_partition_menu()
 {
-    static char* headers[] = {  "Mount and unmount partitions",
+    static char* headers[] = {  "Mounts and Storage Menu",
                                 "",
                                 NULL 
     };
@@ -792,6 +800,8 @@ void show_advanced_menu()
                             "Wipe Battery Stats",
                             "Report Error",
                             "Key Test",
+                            "Partition SD Card",
+                            "Fix Permissions",
                             NULL
     };
 
@@ -809,9 +819,15 @@ void show_advanced_menu()
             {
                 if (0 != ensure_root_path_mounted("DATA:"))
                     break;
-                if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache"))
+                ensure_root_path_mounted("SDEXT:");
+                ensure_root_path_mounted("CACHE:");
+                if (confirm_selection( "Confirm wipe?", "Yes - Wipe Dalvik Cache")) {
                     __system("rm -r /data/dalvik-cache");
+                    __system("rm -r /cache/dalvik-cache");
+                    __system("rm -r /sd-ext/dalvik-cache");
+                }
                 ensure_root_path_unmounted("DATA:");
+                ui_print("Dalvik Cache wiped.\n");
                 break;
             }
             case 2:
@@ -836,6 +852,57 @@ void show_advanced_menu()
                     ui_print("Key: %d\n", key);
                 }
                 while (action != GO_BACK);
+                break;
+            }
+            case 5:
+            {
+                static char* ext_sizes[] = { "128M",
+                                             "256M",
+                                             "512M",
+                                             "1024M",
+                                             NULL };
+
+                static char* swap_sizes[] = { "0M",
+                                              "32M",
+                                              "64M",
+                                              "128M",
+                                              "256M",
+                                              NULL };
+
+                static char* ext_headers[] = { "Ext Size", "", NULL };
+                static char* swap_headers[] = { "Swap Size", "", NULL };
+
+                int ext_size = get_menu_selection(ext_headers, ext_sizes, 0);
+                if (ext_size == GO_BACK)
+                    continue;
+                 
+                int swap_size = get_menu_selection(swap_headers, swap_sizes, 0);
+                if (swap_size == GO_BACK)
+                    continue;
+
+                char sddevice[256];
+                const RootInfo *ri = get_root_info_for_path("SDCARD:");
+                strcpy(sddevice, ri->device);
+                // we only want the mmcblk, not the partition
+                sddevice[strlen("/dev/block/mmcblkX")] = NULL;
+                char cmd[PATH_MAX];
+                setenv("SDPATH", sddevice, 1);
+                sprintf(cmd, "sdparted -es %s -ss %s -efs ext3 -s", ext_sizes[ext_size], swap_sizes[swap_size]);
+                ui_print("Partitioning SD Card... please wait...\n");
+                if (0 == __system(cmd))
+                    ui_print("Done!\n");
+                else
+                    ui_print("An error occured while partitioning your SD Card. Please see /tmp/recovery.log for more details.\n");
+                break;
+            }
+            case 6:
+            {
+                ensure_root_path_mounted("SYSTEM:");
+                ensure_root_path_mounted("DATA:");
+                ui_print("Fixing permissions...\n");
+                __system("fix_permissions");
+                ui_print("Done!\n");
+                break;
             }
         }
     }
@@ -866,7 +933,7 @@ void write_fstab_root(char *root_path, FILE *file)
     }
 
     fprintf(file, "%s ", info->mount_point);
-    fprintf(file, "%s rw\n", info->filesystem); 
+    fprintf(file, "%s %s\n", info->filesystem, info->filesystem_options == NULL ? "rw" : info->filesystem_options); 
 }
 
 void create_fstab()
@@ -896,5 +963,5 @@ void handle_failure(int ret)
         return;
     mkdir("/sdcard/clockworkmod", S_IRWXU);
     __system("cp /tmp/recovery.log /sdcard/clockworkmod/recovery.log");
-    ui_print("/tmp/recovery.log was copied to /sdcard/clockworkmod/recovery.log. Please open ROM Manager to report the issue.");
+    ui_print("/tmp/recovery.log was copied to /sdcard/clockworkmod/recovery.log. Please open ROM Manager to report the issue.\n");
 }

install.c

@@ -42,6 +42,68 @@
 #define ASSUMED_UPDATE_BINARY_NAME  "META-INF/com/google/android/update-binary"
 #define PUBLIC_KEYS_FILE "/res/keys"
 
+// The update binary ask us to install a firmware file on reboot.  Set
+// that up.  Takes ownership of type and filename.
+static int
+handle_firmware_update(char* type, char* filename, ZipArchive* zip) {
+    unsigned int data_size;
+    const ZipEntry* entry = NULL;
+
+    if (strncmp(filename, "PACKAGE:", 8) == 0) {
+        entry = mzFindZipEntry(zip, filename+8);
+        if (entry == NULL) {
+            LOGE("Failed to find \"%s\" in package", filename+8);
+            return INSTALL_ERROR;
+        }
+        data_size = entry->uncompLen;
+    } else {
+        struct stat st_data;
+        if (stat(filename, &st_data) < 0) {
+            LOGE("Error stat'ing %s: %s\n", filename, strerror(errno));
+            return INSTALL_ERROR;
+        }
+        data_size = st_data.st_size;
+    }
+
+    LOGI("type is %s; size is %d; file is %s\n",
+         type, data_size, filename);
+
+    char* data = malloc(data_size);
+    if (data == NULL) {
+        LOGI("Can't allocate %d bytes for firmware data\n", data_size);
+        return INSTALL_ERROR;
+    }
+
+    if (entry) {
+        if (mzReadZipEntry(zip, entry, data, data_size) == false) {
+            LOGE("Failed to read \"%s\" from package", filename+8);
+            return INSTALL_ERROR;
+        }
+    } else {
+        FILE* f = fopen(filename, "rb");
+        if (f == NULL) {
+            LOGE("Failed to open %s: %s\n", filename, strerror(errno));
+            return INSTALL_ERROR;
+        }
+        if (fread(data, 1, data_size, f) != data_size) {
+            LOGE("Failed to read firmware data: %s\n", strerror(errno));
+            return INSTALL_ERROR;
+        }
+        fclose(f);
+    }
+
+#ifndef BOARD_HAS_NO_MISC_PARTITION
+    if (remember_firmware_update(type, data, data_size)) {
+        LOGE("Can't store %s image\n", type);
+        free(data);
+        return INSTALL_ERROR;
+    }
+#endif
+    free(filename);
+
+    return INSTALL_SUCCESS;
+}
+
 // If the package contains an update binary, extract it and run it.
 static int
 try_update_binary(const char *path, ZipArchive *zip) {