diff options
Diffstat (limited to 'heimdall/source/FlashAction.cpp')
| -rw-r--r-- | heimdall/source/FlashAction.cpp | 620 |
1 files changed, 620 insertions, 0 deletions
diff --git a/heimdall/source/FlashAction.cpp b/heimdall/source/FlashAction.cpp new file mode 100644 index 0000000..d79235e --- /dev/null +++ b/heimdall/source/FlashAction.cpp @@ -0,0 +1,620 @@ +/* Copyright (c) 2010-2012 Benjamin Dobell, Glass Echidna + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE.*/ + +// C Standard Library +#include <stdio.h> + +// Heimdall +#include "Arguments.h" +#include "BridgeManager.h" +#include "EndModemFileTransferPacket.h" +#include "EndPhoneFileTransferPacket.h" +#include "FlashAction.h" +#include "Heimdall.h" +#include "Interface.h" +#include "SessionSetupResponse.h" +#include "TotalBytesPacket.h" +#include "Utility.h" + +using namespace Heimdall; + +const char *FlashAction::usage = "Action: flash\n\ +Arguments:\n\ + --repartition --pit <filename> [--factoryfs <filename>]\n\ + [--cache <filename>] [--dbdata <filename>] [--primary-boot <filename>]\n\ + [--secondary-boot <filename>] [--param <filename>] [--kernel <filename>]\n\ + [--modem <filename>] [--radio <filename>] [--normal-boot <filename>]\n\ + [--system <filename>] [--user-data <filename>] [--fota <filename>]\n\ + [--hidden <filename>] [--movinand <filename>] [--data <filename>]\n\ + [--ums <filename>] [--emmc <filename>]\n\ + [--<partition identifier> <filename>]\n\ + [--<partition name> <filename>]\n\ + [--verbose] [--no-reboot] [--stdout-errors] [--delay <ms>]\n\ + or:\n\ + [--factoryfs <filename>] [--cache <filename>] [--dbdata <filename>]\n\ + [--primary-boot <filename>] [--secondary-boot <filename>]\n\ + [--secondary-boot-backup <filename>] [--param <filename>]\n\ + [--kernel <filename>] [--recovery <filename>] [--efs <filename>]\n\ + [--modem <filename>] [--radio <filename>] [--normal-boot <filename>]\n\ + [--system <filename>] [--user-data <filename>] [--fota <filename>]\n\ + [--hidden <filename>] [--movinand <filename>] [--data <filename>]\n\ + [--ums <filename>] [--emmc <filename>] [--pit <filename>]\n\ + [--<partition identifier> <filename>]\n\ + [--<partition name> <filename>]\n\ + [--verbose] [--no-reboot] [--stdout-errors] [--delay <ms>]\n\ +Description: Flashes firmware files to your phone. Partition identifiers are\n\ + integer values, they can be obtained by executing the print-pit action.\n\ +WARNING: If you're repartitioning it's strongly recommended you specify\n\ + all files at your disposal, including bootloaders.\n"; + +struct PartitionFlashInfo +{ + const PitEntry *pitEntry; + FILE *file; + + PartitionFlashInfo(const PitEntry *pitEntry, FILE *file) + { + this->pitEntry = pitEntry; + this->file = file; + } +}; + +static void buildArgumentPartitionNamesMap(map< string, vector<string> >& argumentPartitionNamesMap, map<string, string>& shortArgumentAliases) +{ + argumentPartitionNamesMap["pit"].push_back("PIT"); + argumentPartitionNamesMap["factoryfs"].push_back("FACTORYFS"); + argumentPartitionNamesMap["cache"].push_back("CACHE"); + argumentPartitionNamesMap["dbdata"].push_back("DBDATAFS"); + + argumentPartitionNamesMap["primary-boot"].push_back("IBL+PBL"); + argumentPartitionNamesMap["primary-boot"].push_back("BOOT"); + + argumentPartitionNamesMap["secondary-boot"].push_back("SBL"); + argumentPartitionNamesMap["secondary-boot"].push_back("SBL1"); + + argumentPartitionNamesMap["secondary-boot-backup"].push_back("SBL2"); + argumentPartitionNamesMap["param"].push_back("PARAM"); + argumentPartitionNamesMap["kernel"].push_back("KERNEL"); + argumentPartitionNamesMap["recovery"].push_back("RECOVERY"); + argumentPartitionNamesMap["efs"].push_back("EFS"); + argumentPartitionNamesMap["modem"].push_back("MODEM"); + argumentPartitionNamesMap["radio"].push_back("RADIO"); + argumentPartitionNamesMap["normal-boot"].push_back("NORMALBOOT"); + argumentPartitionNamesMap["system"].push_back("SYSTEM"); + argumentPartitionNamesMap["user-data"].push_back("USERDATA"); + argumentPartitionNamesMap["fota"].push_back("FOTA"); + argumentPartitionNamesMap["hidden"].push_back("HIDDEN"); + argumentPartitionNamesMap["movinand"].push_back("MOVINAND"); + argumentPartitionNamesMap["data"].push_back("DATAFS"); + argumentPartitionNamesMap["ums"].push_back("UMS.EN"); + argumentPartitionNamesMap["emmc"].push_back("GANG"); + + shortArgumentAliases["pit"] = "pit"; + shortArgumentAliases["fs"] = "factoryfs"; + shortArgumentAliases["cache"] = "cache"; + shortArgumentAliases["db"] = "dbdata"; + shortArgumentAliases["boot"] = "primary-boot"; + shortArgumentAliases["sbl"] = "secondary-boot"; + shortArgumentAliases["sbl2"] = "secondary-boot-backup"; + shortArgumentAliases["param"] = "param"; + shortArgumentAliases["z"] = "kernel"; + shortArgumentAliases["rec"] = "recovery"; + shortArgumentAliases["efs"] = "efs"; + shortArgumentAliases["m"] = "modem"; + shortArgumentAliases["rdio"] = "radio"; + shortArgumentAliases["norm"] = "normal-boot"; + shortArgumentAliases["sys"] = "system"; + shortArgumentAliases["udata"] = "user-data"; + shortArgumentAliases["fota"] = "fota"; + shortArgumentAliases["hide"] = "hidden"; + shortArgumentAliases["nand"] = "movinand"; + shortArgumentAliases["data"] = "data"; + shortArgumentAliases["ums"] = "ums"; + shortArgumentAliases["emmc"] = "emmc"; +} + +static bool openFiles(Arguments& arguments, const map< string, vector<string> >& argumentPartitionNamesMap, + map<string, FILE *>& argumentFileMap) +{ + for (map<string, Argument *>::const_iterator it = arguments.GetArguments().begin(); it != arguments.GetArguments().end(); it++) + { + bool isPartitionArgument = false; + const string& argumentName = it->first; + + if (arguments.GetArgumentTypes().find(argumentName) == arguments.GetArgumentTypes().end()) + { + // The only way an argument could exist without being in the argument types map is if it's a wild-card. + // The "%d" wild-card refers to a partition by identifier, where as the "%s" wild-card refers to a + // partition by name. + isPartitionArgument = true; + } + else + { + // The argument wasn't a wild-card, check if it's a known partition name. + if (argumentPartitionNamesMap.find(argumentName) != argumentPartitionNamesMap.end()) + isPartitionArgument = true; + } + + if (isPartitionArgument) + { + const StringArgument *stringArgument = static_cast<StringArgument *>(it->second); + FILE *file = fopen(stringArgument->GetValue().c_str(), "rb"); + + if (!file) + { + Interface::PrintError("Failed to open file \"%s\"\n", stringArgument->GetValue().c_str()); + return (false); + } + + argumentFileMap[it->first] = file; + } + } + + return (true); +} + +static void closeFiles(map<string, FILE *> argumentfileMap) +{ + for (map<string, FILE *>::iterator it = argumentfileMap.begin(); it != argumentfileMap.end(); it++) + fclose(it->second); + + argumentfileMap.clear(); +} + +static bool sendTotalTransferSize(BridgeManager *bridgeManager, const map<string, FILE *>& argumentFileMap, bool repartition) +{ + int totalBytes = 0; + for (map<string, FILE *>::const_iterator it = argumentFileMap.begin(); it != argumentFileMap.end(); it++) + { + if (repartition || it->first != "pit") + { + fseek(it->second, 0, SEEK_END); + totalBytes += ftell(it->second); + rewind(it->second); + } + } + + bool success; + + TotalBytesPacket *totalBytesPacket = new TotalBytesPacket(totalBytes); + success = bridgeManager->SendPacket(totalBytesPacket); + delete totalBytesPacket; + + if (!success) + { + Interface::PrintError("Failed to send total bytes device info packet!\n"); + return (false); + } + + SessionSetupResponse *totalBytesResponse = new SessionSetupResponse(); + success = bridgeManager->ReceivePacket(totalBytesResponse); + int totalBytesResult = totalBytesResponse->GetResult(); + delete totalBytesResponse; + + if (!success) + { + Interface::PrintError("Failed to receive device info response!\n"); + return (false); + } + + if (totalBytesResult != 0) + { + Interface::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%d\n", totalBytesResponse); + return (false); + } + + return (true); +} + +static bool setupPartitionFlashInfo(const map<string, FILE *>& argumentFileMap, const map< string, vector<string> >& argumentPartitionNamesMap, + const PitData *pitData, vector<PartitionFlashInfo>& partitionFlashInfos) +{ + for (map<string, FILE *>::const_iterator it = argumentFileMap.begin(); it != argumentFileMap.end(); it++) + { + const string& argumentName = it->first; + FILE *partitionFile = it->second; + + const PitEntry *pitEntry = nullptr; + + // Was the argument a partition identifier? + unsigned int partitionIdentifier; + + if (Utility::ParseUnsignedInt(partitionIdentifier, argumentName.c_str()) == kNumberParsingStatusSuccess) + { + pitEntry = pitData->FindEntry(partitionIdentifier); + + if (!pitEntry) + { + Interface::PrintError("No partition with identifier \"%s\" exists in the specified PIT.\n", argumentName.c_str()); + return (false); + } + } + else + { + // The argument wasn't a partition identifier. Was it a known human-readable partition name? + map< string, vector<string> >::const_iterator argumentPartitionNamesIt = argumentPartitionNamesMap.find(argumentName); + + if (argumentPartitionNamesIt != argumentPartitionNamesMap.end()) + { + const vector<string>& partitionNames = argumentPartitionNamesIt->second; + + // Check for the partition in the PIT file using all known names. + for (vector<string>::const_iterator nameIt = partitionNames.begin(); nameIt != partitionNames.end(); nameIt++) + { + pitEntry = pitData->FindEntry(nameIt->c_str()); + + if (pitEntry) + break; + } + + if (!pitEntry) + { + Interface::PrintError("Partition name for \"%s\" could not be located\n", argumentName.c_str()); + return (false); + } + } + else + { + // The argument must be an actual partition name. e.g. "ZIMAGE", instead of human-readable "kernel". + pitEntry = pitData->FindEntry(argumentName.c_str()); + + if (!pitEntry) + { + Interface::PrintError("Partition \"%s\" does not exist in the specified PIT.\n", argumentName.c_str()); + return (false); + } + } + } + + partitionFlashInfos.push_back(PartitionFlashInfo(pitEntry, partitionFile)); + } + + return (true); +} + +static bool isKnownPartition(const map<string, vector<string> >& argumentPartitionNamesMap, const string& argumentName, const string& partitionName) +{ + const vector<string>& partitionNames = argumentPartitionNamesMap.find(argumentName)->second; + + for (vector<string>::const_iterator it = partitionNames.begin(); it != partitionNames.end(); it++) + { + if (partitionName == *it) + return (true); + } + + return (false); +} + +static bool isKnownBootPartition(const map<string, vector<string> >& argumentPartitionNamesMap, const char *partitionName) +{ + return (isKnownPartition(argumentPartitionNamesMap, "primary-boot", partitionName) + || isKnownPartition(argumentPartitionNamesMap, "secondary-boot", partitionName) + || isKnownPartition(argumentPartitionNamesMap, "secondary-boot-backup", partitionName) + || isKnownPartition(argumentPartitionNamesMap, "param", partitionName) + || isKnownPartition(argumentPartitionNamesMap, "normal-boot", partitionName) + || strcmp(partitionName, "SBL3") == 0 + || strcmp(partitionName, "ABOOT") == 0 + || strcmp(partitionName, "RPM") == 0 + || strcmp(partitionName, "TZ") == 0); +} + +static bool flashFile(BridgeManager *bridgeManager, const map< string, vector<string> >& argumentPartitionNamesMap, + const PartitionFlashInfo& partitionFlashInfo) +{ + // PIT files need to be handled differently, try determine if the partition we're flashing to is a PIT partition. + + if (isKnownPartition(argumentPartitionNamesMap, "pit", partitionFlashInfo.pitEntry->GetPartitionName())) + { + Interface::Print("Uploading %s\n", partitionFlashInfo.pitEntry->GetPartitionName()); + + if (bridgeManager->SendPitFile(partitionFlashInfo.file)) + { + Interface::Print("%s upload successful\n\n", partitionFlashInfo.pitEntry->GetPartitionName()); + return (true); + } + else + { + Interface::PrintError("%s upload failed!\n\n", partitionFlashInfo.pitEntry->GetPartitionName()); + return (false); + } + } + else + { + if (partitionFlashInfo.pitEntry->GetBinaryType() == PitEntry::kBinaryTypeCommunicationProcessor) // Modem + { + Interface::Print("Uploading %s\n", partitionFlashInfo.pitEntry->GetPartitionName()); + + if (bridgeManager->SendFile(partitionFlashInfo.file, EndModemFileTransferPacket::kDestinationModem, + partitionFlashInfo.pitEntry->GetDeviceType())) // <-- Odin method + { + Interface::Print("%s upload successful\n\n", partitionFlashInfo.pitEntry->GetPartitionName()); + return (true); + } + else + { + Interface::PrintError("%s upload failed!\n\n", partitionFlashInfo.pitEntry->GetPartitionName()); + return (false); + } + } + else // partitionFlashInfo.pitEntry->GetBinaryType() == PitEntry::kBinaryTypeApplicationProcessor + { + Interface::Print("Uploading %s\n", partitionFlashInfo.pitEntry->GetPartitionName()); + + if (bridgeManager->SendFile(partitionFlashInfo.file, EndPhoneFileTransferPacket::kDestinationPhone, + partitionFlashInfo.pitEntry->GetDeviceType(), partitionFlashInfo.pitEntry->GetIdentifier())) + { + Interface::Print("%s upload successful\n\n", partitionFlashInfo.pitEntry->GetPartitionName()); + return (true); + } + else + { + Interface::PrintError("%s upload failed!\n\n", partitionFlashInfo.pitEntry->GetPartitionName()); + return (false); + } + } + } + + return (true); +} + +static bool flashPartitions(const map<string, FILE *>& argumentFileMap, const map< string, vector<string> >& argumentPartitionNamesMap, + const PitData *pitData, BridgeManager *bridgeManager, bool repartition) +{ + vector<PartitionFlashInfo> partitionFlashInfos; + + // Map the files being flashed to partitions stored in the PIT file. + if (!setupPartitionFlashInfo(argumentFileMap, argumentPartitionNamesMap, pitData, partitionFlashInfos)) + return (false); + + // If we're repartitioning then we need to flash the PIT file first. + if (repartition) + { + vector<PartitionFlashInfo>::const_iterator it; + + for (it = partitionFlashInfos.begin(); it != partitionFlashInfos.end(); it++) + { + if (isKnownPartition(argumentPartitionNamesMap, "pit", it->pitEntry->GetPartitionName())) + { + if (!flashFile(bridgeManager, argumentPartitionNamesMap, *it)) + return (false); + + break; + } + } + + if (it == partitionFlashInfos.end()) + { + Interface::PrintError("Could not identify the PIT partition within the specified PIT file.\n\n"); + return (false); + } + } + + // Flash partitions not involved in the boot process second. + for (vector<PartitionFlashInfo>::const_iterator it = partitionFlashInfos.begin(); it != partitionFlashInfos.end(); it++) + { + if (!isKnownPartition(argumentPartitionNamesMap, "pit", it->pitEntry->GetPartitionName()) + && !isKnownBootPartition(argumentPartitionNamesMap, it->pitEntry->GetPartitionName())) + { + if (!flashFile(bridgeManager, argumentPartitionNamesMap, *it)) + return (false); + } + } + + // Flash boot partitions last. + for (vector<PartitionFlashInfo>::const_iterator it = partitionFlashInfos.begin(); it != partitionFlashInfos.end(); it++) + { + if (isKnownBootPartition(argumentPartitionNamesMap, it->pitEntry->GetPartitionName())) + { + if (!flashFile(bridgeManager, argumentPartitionNamesMap, *it)) + return (false); + } + } + + return (true); +} + +static PitData *getPitData(const map<string, FILE *>& argumentFileMap, BridgeManager *bridgeManager, bool repartition) +{ + PitData *pitData; + PitData *localPitData = nullptr; + + // If a PIT file was passed as an argument then we must unpack it. + + map<string, FILE *>::const_iterator localPitFileIt = argumentFileMap.find("pit"); + + if (localPitFileIt != argumentFileMap.end()) + { + FILE *localPitFile = localPitFileIt->second; + + // Load the local pit file into memory. + unsigned char *pitFileBuffer = new unsigned char[4096]; + memset(pitFileBuffer, 0, 4096); + + fseek(localPitFile, 0, SEEK_END); + long localPitFileSize = ftell(localPitFile); + rewind(localPitFile); + + // dataRead is discarded, it's here to remove warnings. + int dataRead = fread(pitFileBuffer, 1, localPitFileSize, localPitFile); + rewind(localPitFile); + + localPitData = new PitData(); + localPitData->Unpack(pitFileBuffer); + + delete [] pitFileBuffer; + } + + if (repartition) + { + // Use the local PIT file data. + pitData = localPitData; + } + else + { + // If we're not repartitioning then we need to retrieve the device's PIT file and unpack it. + unsigned char *pitFileBuffer; + + if (bridgeManager->DownloadPitFile(&pitFileBuffer) == 0) + return (nullptr); + + pitData = new PitData(); + pitData->Unpack(pitFileBuffer); + + delete [] pitFileBuffer; + + if (localPitData != nullptr) + { + // The user has specified a PIT without repartitioning, we should verify the local and device PIT data match! + bool pitsMatch = pitData->Matches(localPitData); + delete localPitData; + + if (!pitsMatch) + { + Interface::Print("Local and device PIT files don't match and repartition wasn't specified!\n"); + Interface::PrintError("Flash aborted!\n"); + return (nullptr); + } + } + } + + return (pitData); +} + +int FlashAction::Execute(int argc, char **argv) +{ + // Setup argument types + + map<string, ArgumentType> argumentTypes; + + argumentTypes["repartition"] = kArgumentTypeString; + + argumentTypes["no-reboot"] = kArgumentTypeFlag; + argumentTypes["delay"] = kArgumentTypeUnsignedInteger; + argumentTypes["verbose"] = kArgumentTypeFlag; + argumentTypes["stdout-errors"] = kArgumentTypeFlag; + + map< string, vector<string> > argumentPartitionNamesMap; + map<string, string> shortArgumentAliases; + + buildArgumentPartitionNamesMap(argumentPartitionNamesMap, shortArgumentAliases); + + for (map< string, vector<string> >::const_iterator it = argumentPartitionNamesMap.begin(); it != argumentPartitionNamesMap.end(); it++) + argumentTypes[it->first] = kArgumentTypeString; + + // Add wild-cards "%d" and "%s", for partition identifiers and partition names respectively. + argumentTypes["%d"] = kArgumentTypeString; + shortArgumentAliases["%d"] = "%d"; + + argumentTypes["%s"] = kArgumentTypeString; + shortArgumentAliases["%s"] = "%s"; + + map<string, string> argumentAliases; + argumentAliases["PIT"] = "pit"; // Map upper-case PIT argument (i.e. partition name) to known lower-case pit argument. + + // Handle arguments + + Arguments arguments(argumentTypes, shortArgumentAliases, argumentAliases); + + if (!arguments.ParseArguments(argc, argv, 2)) + { + Interface::Print(FlashAction::usage); + return (0); + } + + const UnsignedIntegerArgument *communicationDelayArgument = static_cast<const UnsignedIntegerArgument *>(arguments.GetArgument("delay")); + + bool reboot = arguments.GetArgument("no-reboot") == nullptr; + bool verbose = arguments.GetArgument("verbose") != nullptr; + + if (arguments.GetArgument("stdout-errors") != nullptr) + Interface::SetStdoutErrors(true); + + const StringArgument *pitArgument = static_cast<const StringArgument *>(arguments.GetArgument("pit")); + + bool repartition = arguments.GetArgument("repartition") != nullptr; + + if (repartition && !pitArgument) + { + Interface::Print("If you wish to repartition then a PIT file must be specified.\n\n"); + Interface::Print(FlashAction::usage); + return (0); + } + + // Open files + + map<string, FILE *> argumentFileMap; + + if (!openFiles(arguments, argumentPartitionNamesMap, argumentFileMap)) + { + closeFiles(argumentFileMap); + return (1); + } + + if (argumentFileMap.size() == 0) + { + Interface::Print(FlashAction::usage); + return (0); + } + + // Info + + Interface::PrintReleaseInfo(); + Sleep(1000); + + // Perform flash + + int communicationDelay = BridgeManager::kCommunicationDelayDefault; + + if (communicationDelayArgument) + communicationDelay = communicationDelayArgument->GetValue(); + + BridgeManager *bridgeManager = new BridgeManager(verbose, communicationDelay); + + if (bridgeManager->Initialise() != BridgeManager::kInitialiseSucceeded || !bridgeManager->BeginSession()) + { + closeFiles(argumentFileMap); + delete bridgeManager; + + return (1); + } + + bool success = sendTotalTransferSize(bridgeManager, argumentFileMap, repartition); + + if (success) + { + PitData *pitData = getPitData(argumentFileMap, bridgeManager, repartition); + + if (pitData) + success = flashPartitions(argumentFileMap, argumentPartitionNamesMap, pitData, bridgeManager, repartition); + else + success = false; + + delete pitData; + } + + closeFiles(argumentFileMap); + + if (!bridgeManager->EndSession(reboot)) + success = false; + + delete bridgeManager; + + return (success ? 0 : 1); +} |