TWRP-ify AOSP code
Pull in most TWRP sources
Stub out partition management code
Make it compile -- probably will not boot
Kind of a mess but have to start somewhere
diff --git a/htcdumlock/htcdumlock.c b/htcdumlock/htcdumlock.c
new file mode 100644
index 0000000..0bae6b8
--- /dev/null
+++ b/htcdumlock/htcdumlock.c
@@ -0,0 +1,406 @@
+/*
+ * This binary is a workaround for HTC's unlock method that doesn't let
+ * you flash boot while booted to recovery. It is designed to dump
+ * recovery and boot to the sdcard then flash recovery to boot. When
+ * used with a supported recovery, you can reflash the dumped copy of
+ * boot once you enter the recovery.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * The code was written from scratch by Dees_Troy dees_troy at
+ * yahoo
+ *
+ * Copyright (c) 2012
+ *
+ * Note that this all could probably be done as a shell script, but
+ * I am much better at C than I am at scripting. :)
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+// Number of bytes in the ramdisks to compare
+#define SCAN_SIZE 60
+
+#define CMDLINE_SERIALNO "androidboot.serialno="
+#define CMDLINE_SERIALNO_LEN (strlen(CMDLINE_SERIALNO))
+#define CPUINFO_SERIALNO "Serial"
+#define CPUINFO_SERIALNO_LEN (strlen(CPUINFO_SERIALNO))
+#define CPUINFO_HARDWARE "Hardware"
+#define CPUINFO_HARDWARE_LEN (strlen(CPUINFO_HARDWARE))
+
+char device_id[255];
+int verbose = 0, java = 0;
+
+void get_device_id(void)
+{
+ FILE *fp;
+ char line[2048];
+ char hardware_id[32];
+ char* token;
+
+ // Assign a blank device_id to start with
+ device_id[0] = 0;
+
+ // First, try the cmdline to see if the serial number was supplied
+ fp = fopen("/proc/cmdline", "rt");
+ if (fp != NULL)
+ {
+ // First step, read the line. For cmdline, it's one long line
+ fgets(line, sizeof(line), fp);
+ fclose(fp);
+
+ // Now, let's tokenize the string
+ token = strtok(line, " ");
+
+ // Let's walk through the line, looking for the CMDLINE_SERIALNO token
+ while (token)
+ {
+ // We don't need to verify the length of token, because if it's too short, it will mismatch CMDLINE_SERIALNO at the NULL
+ if (memcmp(token, CMDLINE_SERIALNO, CMDLINE_SERIALNO_LEN) == 0)
+ {
+ // We found the serial number!
+ strcpy(device_id, token + CMDLINE_SERIALNO_LEN);
+ return;
+ }
+ token = strtok(NULL, " ");
+ }
+ }
+
+ // Now we'll try cpuinfo for a serial number
+ fp = fopen("/proc/cpuinfo", "rt");
+ if (fp != NULL)
+ {
+ while (fgets(line, sizeof(line), fp) != NULL) { // First step, read the line.
+ if (memcmp(line, CPUINFO_SERIALNO, CPUINFO_SERIALNO_LEN) == 0) // check the beginning of the line for "Serial"
+ {
+ // We found the serial number!
+ token = line + CPUINFO_SERIALNO_LEN; // skip past "Serial"
+ while (((int)*token > 0 && (int)*token <= 32 ) || (int)*token == ':') token++; // skip over all spaces and the colon
+ if (*token != NULL) {
+ token[30] = 0;
+ if (token[strlen(token)-1] == 10) { // checking for endline chars and dropping them from the end of the string if needed
+ memset(device_id, 0, sizeof(device_id));
+ strncpy(device_id, token, strlen(token) - 1);
+ } else {
+ strcpy(device_id, token);
+ }
+ if (verbose)
+ printf("serial from cpuinfo: '%s'\n", device_id);
+ fclose(fp);
+ return;
+ }
+ } else if (memcmp(line, CPUINFO_HARDWARE, CPUINFO_HARDWARE_LEN) == 0) {// We're also going to look for the hardware line in cpuinfo and save it for later in case we don't find the device ID
+ // We found the hardware ID
+ token = line + CPUINFO_HARDWARE_LEN; // skip past "Hardware"
+ while (((int)*token > 0 && (int)*token <= 32 ) || (int)*token == ':') token++; // skip over all spaces and the colon
+ if (*token != NULL) {
+ token[30] = 0;
+ if (token[strlen(token)-1] == 10) { // checking for endline chars and dropping them from the end of the string if needed
+ memset(hardware_id, 0, sizeof(hardware_id));
+ strncpy(hardware_id, token, strlen(token) - 1);
+ } else {
+ strcpy(hardware_id, token);
+ }
+ if (verbose)
+ printf("hardware id from cpuinfo: '%s'\n", hardware_id);
+ }
+ }
+ }
+ fclose(fp);
+ }
+
+ if (hardware_id[0] != 0) {
+ if (verbose)
+ printf("using hardware id for device id: '%s'\n", hardware_id);
+ strcpy(device_id, hardware_id);
+ return;
+ }
+
+ strcpy(device_id, "serialno");
+ if (verbose)
+ printf("device id not found, using '%s'.", device_id);
+ return;
+}
+
+void reboot_device() {
+ // Reboot
+ printf("Rebooting!\n");
+ system("reboot system");
+}
+
+void scan_for_ramdisk_data(char *filename, char *ramdisk) {
+ FILE *pFile;
+ unsigned long lSize;
+ unsigned char *buffer;
+ size_t result;
+ int i;
+
+ pFile = fopen(filename, "rb");
+ if(pFile==NULL){
+ printf("Unabled to open image.\nFailed\n");
+ exit(1);
+ }
+
+ fseek (pFile , 0 , SEEK_END);
+ lSize = ftell(pFile);
+ rewind(pFile);
+
+ //printf("\n\nFile is %ld bytes big\n\n", lSize);
+
+ buffer = (unsigned char*)malloc(sizeof(unsigned char) * lSize);
+ if(buffer == NULL){
+ printf("File read error!\nFailed\n");
+ exit(2);
+ }
+
+ result = fread (buffer, 1, lSize, pFile);
+ if (result != lSize) {
+ printf("Error reading file '%s'\nFailed\n", filename);
+ exit(3);
+ }
+
+ unsigned char needle[6] = {0x00, 0x00, 0x00, 0x00, 0x1f, 0x8b};
+ unsigned char *last_needle = NULL;
+ //char *p = memmem(needle, lSize, buffer, sizeof(needle));
+ unsigned char *p = memmem(buffer + 2048, lSize - 2048, needle, sizeof(needle));
+ if (!p) {
+ fclose(pFile);
+ printf("Ramdisk not found in '%s', error!\nFailed\n", filename);
+ exit(4);
+ } else {
+ //printf("Ramdisk found in '%s'!\n", filename);
+ }
+
+ memcpy(ramdisk, p, sizeof(char) * SCAN_SIZE);
+ fclose(pFile);
+ free(buffer);
+}
+
+int compare_ramdisks(char *boot_path, char *recovery_path) {
+ char boot_data[SCAN_SIZE], recovery_data[SCAN_SIZE];
+
+ scan_for_ramdisk_data(boot_path, (char*)&boot_data);
+ scan_for_ramdisk_data(recovery_path, (char*)&recovery_data);
+ if (memcmp(boot_data, recovery_data, sizeof(boot_data)) == 0) {
+ if (verbose)
+ printf("Boot and recovery are the same.\n");
+ return 0;
+ } else {
+ if (verbose)
+ printf("Boot and recovery are NOT the same.\n");
+ return 1;
+ }
+}
+
+void flash_recovery_to_boot(int no_flash, int no_reboot) {
+ char twrp_device_path[255], recovery_path[255], boot_path[255],
+ exec[255], md5recovery[255], md5boot[255],
+ recoveryimg[255], bootimg[255], tempimg[255];
+ int ret_val = 0;
+ FILE *fp;
+ char* token;
+
+ // Create folders
+ if (verbose)
+ printf("Making '/sdcard/TWRP'\n");
+ mkdir("/sdcard/TWRP", 0777);
+ if (verbose)
+ printf("Making folder '/sdcard/TWRP/htcdumlock'\n");
+ mkdir("/sdcard/TWRP/htcdumlock", 0777);
+ strcpy(twrp_device_path, "/sdcard/TWRP/htcdumlock/");
+ strcat(twrp_device_path, device_id);
+ if (verbose)
+ printf("Making folder '%s'\n", twrp_device_path);
+ mkdir(twrp_device_path, 0777);
+ // Make folder for recovery
+ strcpy(recovery_path, twrp_device_path);
+ strcat(recovery_path, "/recovery");
+ if (verbose)
+ printf("Making folder '%s'\n", recovery_path);
+ mkdir(recovery_path, 0777);
+ strcat(recovery_path, "/");
+ // Make folder for boot
+ strcpy(boot_path, twrp_device_path);
+ strcat(boot_path, "/boot");
+ if (verbose)
+ printf("Making folder '%s'\n", boot_path);
+ mkdir(boot_path, 0777);
+ strcat(boot_path, "/");
+
+ // Set up file locations
+ strcpy(recoveryimg, recovery_path);
+ strcat(recoveryimg, "recovery.img");
+ strcpy(bootimg, boot_path);
+ strcat(bootimg, "boot.img");
+ strcpy(tempimg, twrp_device_path);
+ strcat(tempimg, "/temp.img");
+
+ // Dump recovery
+ strcpy(exec, "dump_image recovery ");
+ strcat(exec, recoveryimg);
+ if (verbose)
+ printf("Running command: '%s'\n", exec);
+ ret_val = system(exec);
+ if (ret_val != 0) {
+ printf("Unable to dump recovery.\nFailed\n");
+ return;
+ }
+
+ // Dump boot (kernel)
+ strcpy(exec, "dump_image boot ");
+ strcat(exec, tempimg);
+ if (verbose)
+ printf("Running command: '%s'\n", exec);
+ ret_val = system(exec);
+ if (ret_val != 0) {
+ printf("Unable to dump recovery.\nFailed\n");
+ return;
+ }
+
+ // Compare the ramdisks of the images from boot and recovery to make sure they are different
+ // If they are the same, then recovery is already flashed to boot and we don't want to wipe
+ // out our existing backup of boot
+ if (compare_ramdisks(tempimg, recoveryimg) != 0) {
+ if (verbose)
+ printf("Boot and recovery do not match so recovery is not flashed to boot yet...\n");
+ strcpy(exec, "mv ");
+ strcat(exec, tempimg);
+ strcat(exec, " ");
+ strcat(exec, bootimg);
+ if (verbose)
+ printf("Moving temporary boot.img: '%s'\n", exec);
+ ret_val = system(exec);
+ if (ret_val != 0) {
+ printf("Unable to move temporary boot image.\nFailed\n");
+ return;
+ }
+ } else {
+ if (!java)
+ printf("Ramdisk recovery and boot matches! Recovery is already flashed to boot!\n");
+ if (!no_reboot)
+ reboot_device();
+ return;
+ }
+
+ // Flash recovery to boot
+ strcpy(exec, "flash_image boot ");
+ strcat(exec, recoveryimg);
+ if (no_flash) {
+ if (verbose)
+ printf("NOT flashing recovery to boot due to argument 'noflash', command is '%s'\n", exec);
+ } else {
+ if (verbose)
+ printf("Running command: '%s'\n", exec);
+ ret_val = system(exec);
+ if (ret_val != 0) {
+ printf("Unable to flash recovery to boot.\nFailed\n");
+ return;
+ }
+ }
+
+ if (!no_reboot && !ret_val)
+ reboot_device();
+}
+
+void restore_original_boot(int no_flash) {
+ char boot_path[255], exec[255];
+
+ // Restore original boot partition
+ strcpy(boot_path, "/sdcard/TWRP/htcdumlock/");
+ strcat(boot_path, device_id);
+ strcat(boot_path, "/boot/");
+ strcpy(exec, "flash_image boot ");
+ strcat(exec, boot_path);
+ strcat(exec, "boot.img");
+ if (no_flash) {
+ if (verbose)
+ printf("NOT restoring boot due to argument 'noflash', command is '%s'\n", exec);
+ } else {
+ if (verbose)
+ printf("Running command: '%s'\n", exec);
+ system(exec);
+ }
+}
+
+int main(int argc, char** argv)
+{
+ int recovery = 0, no_flash = 0, restore_boot = 0, arg_error = 0,
+ no_reboot = 0, i;
+
+ // Parse the arguments
+ if (argc < 2)
+ arg_error = 1;
+ else {
+ for (i=1; i<argc; i++) {
+ if (strcmp(argv[i], "recovery") == 0) {
+ // Check to see if restore option is already set
+ // Do not allow user to do recovery and restore at the same time
+ if (restore_boot)
+ arg_error = 1;
+ recovery = 1;
+ } else if (strcmp(argv[i], "restore") == 0) {
+ // Check to see if recovery option is already set
+ // Do not allow user to do recovery and restore at the same time
+ if (recovery)
+ arg_error = 1;
+ restore_boot = 1;
+ } else if (strcmp(argv[i], "noflash") == 0)
+ no_flash = 1;
+ else if (strcmp(argv[i], "noreboot") == 0)
+ no_reboot = 1;
+ else if (strcmp(argv[i], "verbose") == 0)
+ verbose = 1;
+ else if (strcmp(argv[i], "java") == 0)
+ java = 1;
+ else
+ arg_error = 1;
+ }
+ }
+ if (arg_error) {
+ printf("Invalid argument given.\n");
+ printf("Valid arguments are:\n");
+ printf(" recovery -- backs up boot and recovery and flashes recovery to boot\n");
+ printf(" restore -- restores the most recent backup of boot made by this utility\n");
+ printf(" noflash -- same as 'recovery' but does not flash boot or reboot at the end\n");
+ printf(" noreboot -- does not reboot after flashing boot during 'recovery'\n");
+ printf(" verbose -- show extra debug information\n");
+ printf("\nNOTE: You cannot do 'recovery' and 'restore' in the same operation.\nFailed\n");
+ return 0;
+ }
+
+ get_device_id();
+ if (verbose)
+ printf("Device ID is: '%s'\n", device_id);
+ if (strcmp(device_id, "0000000000000000") == 0) {
+ printf("Error, device ID is all zeros!\n");
+ printf("Did you 'su' first? HTC Dumlock requires root access.\nFailed\n");
+ return 0;
+ }
+
+ if (recovery) {
+ if (!java)
+ printf("Flashing recovery to boot, this may take a few minutes . . .\n");
+ flash_recovery_to_boot(no_flash, no_reboot);
+ }
+ if (restore_boot) {
+ printf("Restoring boot, this may take a few minutes . . .\n");
+ restore_original_boot(no_flash);
+ }
+
+ return 0;
+}