Heimdall 1.4 RC1:

    - Massive refactoring.
    - Support for Qualcomm based devices.
    - Print PIT from file.
    - Use partition names as arguments e.g. --HIDDEN, --KERNEL, --MOVINAND etc.
    - Heimdall Frontend UI improvements.
    - And much more...

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);
+}