Removed the "Heimdall" folder and moved its contents to the root directory.

1 files changed, 660 insertions, 0 deletions

diff --git a/heimdall/source/main.cpp b/heimdall/source/main.cpp
new file mode 100644
index 0000000..037d097
--- /dev/null
+++ b/heimdall/source/main.cpp
@@ -0,0 +1,660 @@
+/* Copyright (c) 2010 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/C++ Standard Library
+#include <algorithm>
+#include <map>
+#include <stdio.h>
+#include <string>
+
+// Heimdall
+#include "BridgeManager.h"
+#include "DeviceInfoPacket.h"
+#include "DeviceInfoResponse.h"
+#include "EndModemFileTransferPacket.h"
+#include "EndPhoneFileTransferPacket.h"
+#include "InterfaceManager.h"
+
+using namespace std;
+using namespace Heimdall;
+
+enum
+{
+	kFilePit = 0,
+	kFileFactoryFs,
+	kFileCache,
+	kFileData,
+	kFilePrimaryBootloader,
+	kFileSecondaryBootloader,
+	kFileSecondaryBootloaderBackup,
+	kFileParam,
+	kFileKernel,
+	kFileRecovery,
+	kFileEfs,
+	kFileModem,
+	kFileCount
+};
+
+bool flashFile(BridgeManager *bridgeManager, FILE *file, int fileIndex)
+{
+	switch (fileIndex)
+	{
+		case kFilePit:
+
+			InterfaceManager::Print("Uploading PIT file\n");
+			if (bridgeManager->SendPitFile(file))
+			{
+				InterfaceManager::Print("PIT file upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("PIT file upload failed!\n");
+				return (false);
+			}
+
+		case kFileFactoryFs:
+
+			InterfaceManager::Print("Uploading factory filesytem\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileFactoryFilesystem))
+			{
+				InterfaceManager::Print("Factory filesytem upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Factory filesytem upload failed!\n");
+				return (false);
+			}
+
+		case kFileCache:
+
+			InterfaceManager::Print("Uploading cache\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileCache))
+			{
+				InterfaceManager::Print("Cache upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Cache upload failed!\n");
+				return (false);
+			}
+
+		case kFileData:
+
+			InterfaceManager::Print("Uploading data database\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileDatabaseData))
+			{
+				InterfaceManager::Print("Data database upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Data database upload failed!\n");
+				return (false);
+			}
+
+		case kFilePrimaryBootloader:
+
+			InterfaceManager::Print("Uploading primary bootloader\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFilePrimaryBootloader))
+			{
+				InterfaceManager::Print("Primary bootloader upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Primary bootloader upload failed!\n");
+				return (false);
+			}
+
+		case kFileSecondaryBootloader:
+
+			InterfaceManager::Print("Uploading secondary bootloader\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileSecondaryBootloader))
+			{
+				InterfaceManager::Print("Secondary bootloader upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Secondary bootloader upload failed!\n");
+				return (false);
+			}
+
+		case kFileSecondaryBootloaderBackup:
+
+			InterfaceManager::Print("Uploading backup secondary bootloader\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileSecondaryBootloaderBackup))
+			{
+				InterfaceManager::Print("Backup secondary bootloader upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Backup secondary bootloader upload failed!\n");
+				return (false);
+			}
+
+		case kFileParam:
+			InterfaceManager::Print("Uploading param.lfs\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileParamLfs))
+			{
+				InterfaceManager::Print("param.lfs upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("param.lfs upload failed!\n");
+				return (false);
+			}
+
+		case kFileKernel:
+
+			InterfaceManager::Print("Uploading kernel\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileKernel))
+			{
+				InterfaceManager::Print("Kernel upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Kernel upload failed!\n");
+				return (false);
+			}
+
+		case kFileModem:
+
+			InterfaceManager::Print("Uploading modem\n");
+			
+			/*if (bridgeManager->SendFile(file, EndModemFileTransferPacket::kDestinationModem))*/	// <-- Odin method
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,		// <-- Kies method
+				EndPhoneFileTransferPacket::kFileModem))
+			{
+				InterfaceManager::Print("Modem upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Modem upload failed!\n");
+				return (false);
+			}
+
+		case kFileRecovery:
+
+			InterfaceManager::Print("Uploading recovery\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileRecovery))
+			{
+				InterfaceManager::Print("Recovery upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("Recovery upload failed!\n");
+				return (false);
+			}
+
+		case kFileEfs:
+
+			InterfaceManager::Print("Uploading EFS\n");
+			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,
+				EndPhoneFileTransferPacket::kFileEfs))
+			{
+				InterfaceManager::Print("EFS upload successful\n");
+				return (true);
+			}
+			else
+			{
+				InterfaceManager::PrintError("EFS upload failed!\n");
+				return (false);
+			}
+
+		default:
+
+			InterfaceManager::PrintError("ERROR: Attempted to flash unknown file!\n");
+			return (false);
+	}
+}
+
+bool attemptFlash(BridgeManager *bridgeManager, FILE **fileArray, bool repartition)
+{
+	bool success;
+	
+	// ---------- GET DEVICE INFORMATION ----------
+
+	DeviceInfoPacket *deviceInfoPacket = new DeviceInfoPacket(DeviceInfoPacket::kUnknown1);
+	success = bridgeManager->SendPacket(deviceInfoPacket);
+	delete deviceInfoPacket;
+
+	if (!success)
+	{
+		InterfaceManager::PrintError("Failed to send device info packet!\nFailed Request: kUnknown1\n");
+		return (false);
+	}
+
+	DeviceInfoResponse *deviceInfoResponse = new DeviceInfoResponse();
+	success = bridgeManager->ReceivePacket(deviceInfoResponse);
+	int unknown = deviceInfoResponse->GetUnknown();
+	delete deviceInfoResponse;
+
+	if (!success)
+	{
+		InterfaceManager::PrintError("Failed to receive device info response!\n");
+		return (false);
+	}
+
+	if (unknown != 0)
+	{
+		InterfaceManager::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%i\n", unknown);
+
+		if (!bridgeManager->EndSession())
+			return (false);
+		bridgeManager->RebootDevice();
+
+		return (false);
+	}
+
+	// -------------------- KIES DOESN'T DO THIS --------------------
+	deviceInfoPacket = new DeviceInfoPacket(DeviceInfoPacket::kUnknown2);
+	success = bridgeManager->SendPacket(deviceInfoPacket);
+	delete deviceInfoPacket;
+
+	if (!success)
+	{
+		InterfaceManager::PrintError("Failed to send device info packet!\nFailed Request: kUnknown2\n");
+		return (false);
+	}	
+
+	deviceInfoResponse = new DeviceInfoResponse();
+	success = bridgeManager->ReceivePacket(deviceInfoResponse);
+	unknown = deviceInfoResponse->GetUnknown();
+	delete deviceInfoResponse;
+
+	if (!success)
+	{
+		InterfaceManager::PrintError("Failed to receive device info response!\n");
+		return (false);
+	}
+
+	// TODO: Work out what this value is... it has been either 180 or 0 for Galaxy S phones, and 3 on the Galaxy Tab.
+	if (unknown != 180 && unknown != 0 && unknown != 3)
+	{
+		InterfaceManager::PrintError("Unexpected device info response!\nExpected: 180, 0 or 3\nReceived:%i\n", unknown);
+
+		if (!bridgeManager->EndSession())
+			return (false);
+		bridgeManager->RebootDevice();
+
+		return (false);
+	}
+	// --------------------------------------------------------------
+
+	int totalBytes = 0;
+	for (int i = kFileFactoryFs; i < kFileCount; i++)
+	{
+		if (fileArray[i])
+		{
+			fseek(fileArray[i], 0, SEEK_END);
+			totalBytes += ftell(fileArray[i]);
+			rewind(fileArray[i]);
+		}
+	}
+
+	if (repartition)
+	{
+		// When repartitioning we send the PIT file to the device.
+		fseek(fileArray[kFilePit], 0, SEEK_END);
+		totalBytes += ftell(fileArray[kFilePit]);
+		rewind(fileArray[kFilePit]);
+	}
+	
+	deviceInfoPacket = new DeviceInfoPacket(DeviceInfoPacket::kTotalBytes, totalBytes);
+	success = bridgeManager->SendPacket(deviceInfoPacket);
+	delete deviceInfoPacket;
+
+	if (!success)
+	{
+		InterfaceManager::PrintError("Failed to send total bytes device info packet!\n");
+		return (false);
+	}
+
+	deviceInfoResponse = new DeviceInfoResponse();
+	success = bridgeManager->ReceivePacket(deviceInfoResponse);
+	unknown = deviceInfoResponse->GetUnknown();
+	delete deviceInfoResponse;
+
+	if (!success)
+	{
+		InterfaceManager::PrintError("Failed to receive device info response!\n");
+		return (false);
+	}
+
+	if (unknown != 0)
+	{
+		InterfaceManager::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%i\n", unknown);
+
+		if (!bridgeManager->EndSession())
+			return (false);
+		bridgeManager->RebootDevice();
+
+		return (false);
+	}
+
+	// -----------------------------------------------------
+
+	if (fileArray[kFilePit])
+	{
+		if (repartition)
+		{
+			flashFile(bridgeManager, fileArray[kFilePit], kFilePit);
+		}
+		else // We're performing a PIT check
+		{
+			// Load the local pit file into memory.
+			char *localPit = new char[4096];
+			memset(localPit, 0, 4096);
+
+			fseek(fileArray[kFilePit], 0, SEEK_END);
+			long localPitFileSize = ftell(fileArray[kFilePit]);
+			rewind(fileArray[kFilePit]);
+
+			fread(localPit, 1, localPitFileSize, fileArray[kFilePit]);
+
+			InterfaceManager::Print("Downloading device's PIT file...\n");
+
+			unsigned char *devicePit;
+			int devicePitFileSize = bridgeManager->ReceivePitFile(&devicePit);
+
+			if (!devicePit)
+			{
+				InterfaceManager::PrintError("Failed to download PIT file!\n");
+
+				if (!bridgeManager->EndSession())
+					return (false);
+				bridgeManager->RebootDevice();
+
+				return (false);
+			}
+
+			InterfaceManager::Print("PIT file download sucessful\n\n");
+
+			bool pitFilesMatch = !memcmp(localPit, devicePit, localPitFileSize);
+
+			delete [] localPit;
+			delete [] devicePit;
+
+			if (!pitFilesMatch)
+			{
+				InterfaceManager::Print("Optional PIT check failed! To disable this check don't use the --pit parameter.");
+
+				if (!bridgeManager->EndSession())
+					return (false);
+				bridgeManager->RebootDevice();
+
+				return (false);
+			}
+		}
+	}
+
+	// Flash specified files
+	for (int fileIndex = kFileFactoryFs; fileIndex < kFileCount; fileIndex++)
+	{
+		if (fileArray[fileIndex])
+		{
+			if (!flashFile(bridgeManager, fileArray[fileIndex], fileIndex))
+				return (false);
+		}
+	}
+
+	return (bridgeManager->EndSession() && bridgeManager->RebootDevice());
+}
+
+bool openFiles(const map<string, string>& argumentMap, FILE **fileArray)
+{
+	for (int fileIndex = 0; fileIndex < kFileCount; fileIndex++)
+	{
+		// kFlashArgPit + kFile<Name> == kFlashArg<Name>
+		map<string, string>::const_iterator it = argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit + fileIndex]);
+		if (it == argumentMap.end())
+			continue;
+
+		fileArray[fileIndex] = fopen(it->second.c_str(), "rb");
+		if (!fileArray[fileIndex])
+		{
+			InterfaceManager::PrintError("Failed to open file \"%s\"\n", it->second.c_str());
+			return (false);
+		}
+	}
+
+	return (true);
+}
+
+void closeFiles(FILE **fileArray)
+{
+	for (int fileIndex = 0; fileIndex < kFileCount; fileIndex++)
+	{
+		if (fileArray[fileIndex] != nullptr)
+			fclose(fileArray[fileIndex]);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	map<string, string> argumentMap;
+	int actionIndex;
+
+	if (!InterfaceManager::GetArguments(argc, argv, argumentMap, &actionIndex))
+	{
+		Sleep(1000);
+		return (0);
+	}
+
+	if (actionIndex == InterfaceManager::kActionHelp)
+	{
+		InterfaceManager::Print(InterfaceManager::usage);
+		return (0);
+	}
+	else if (actionIndex == InterfaceManager::kActionFlash)
+	{
+		if (argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgRepartition]) != argumentMap.end()
+			&& (argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgFactoryFs]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgCache]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgData]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPrimaryBootloader]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgSecondaryBootloader]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgParam]) == argumentMap.end()
+			|| argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgKernel]) == argumentMap.end()))
+		{
+			InterfaceManager::Print("If you wish to repartition then factoryfs, cache, dbdata, primary and secondary\nbootloaders, param, kernel and a PIT file must all be specified.\n");
+			return (0);
+		}
+	}
+	else if (actionIndex == InterfaceManager::kActionDump)
+	{
+		if (argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgOutput]) == argumentMap.end())
+		{
+			InterfaceManager::Print("Output file not specified.\n\n");
+			InterfaceManager::Print(InterfaceManager::usage);
+			return (0);
+		}
+
+		if (argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipType]) == argumentMap.end())
+		{
+			InterfaceManager::Print("You must specify a chip type.\n\n");
+			InterfaceManager::Print(InterfaceManager::usage);
+			return (0);
+		}
+
+		string chipType = argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipType])->second;
+		if (!(chipType == "RAM" || chipType == "ram" || chipType == "NAND" || chipType == "nand"))
+		{
+			InterfaceManager::Print("Unknown chip type: %s.\n\n", chipType.c_str());
+			InterfaceManager::Print(InterfaceManager::usage);
+			return (0);
+		}
+
+		if (argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipId]) == argumentMap.end())
+		{
+			InterfaceManager::Print("You must specify a Chip ID.\n\n");
+			InterfaceManager::Print(InterfaceManager::usage);
+			return (0);
+		}
+
+		int chipId = atoi(argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipId])->second.c_str());
+		if (chipId < 0)
+		{
+			InterfaceManager::Print("Chip ID must be a non-negative integer.\n");
+			return (0);
+		}
+	}
+
+	InterfaceManager::Print("\nHeimdall, Copyright (c) 2010, Benjamin Dobell, Glass Echidna\n");
+	InterfaceManager::Print("http://www.glassechidna.com.au\n\n");
+	InterfaceManager::Print("This software is provided free of charge. Copying and redistribution is\nencouraged.\n\n");
+	InterfaceManager::Print("If you appreciate this software and you would like to support future\ndevelopment please consider donating:\n");
+	InterfaceManager::Print("http://www.glassechidna.com.au/donate/\n\n");
+	
+	Sleep(1000);
+
+	bool verbose = argumentMap.find(InterfaceManager::commonArgumentNames[InterfaceManager::kCommonArgVerbose]) != argumentMap.end();
+
+	int communicationDelay = BridgeManager::kCommunicationDelayDefault;
+	if (argumentMap.find(InterfaceManager::commonArgumentNames[InterfaceManager::kCommonArgDelay]) != argumentMap.end())
+		communicationDelay = atoi(argumentMap.find(InterfaceManager::commonArgumentNames[InterfaceManager::kCommonArgDelay])->second.c_str());
+
+	BridgeManager *bridgeManager = new BridgeManager(verbose, communicationDelay);
+
+	if (!bridgeManager->Initialise())
+	{
+		delete bridgeManager;
+		return (-2);
+	}
+
+	bool success;
+
+	switch (actionIndex)
+	{
+		case InterfaceManager::kActionFlash:
+		{
+			FILE **fileArray = new FILE *[kFileCount];
+			for (int i = 0; i < kFileCount; i++)
+				fileArray[i] = nullptr;
+
+			// We open the files before doing anything else to ensure they exist.
+			if (!openFiles(argumentMap, fileArray))
+			{
+				closeFiles(fileArray);
+				delete [] fileArray;
+
+				delete bridgeManager;
+
+				return (0);
+			}
+
+			if (!bridgeManager->BeginSession())
+			{
+				closeFiles(fileArray);
+				delete [] fileArray;
+
+				delete bridgeManager;
+
+				return (-1);
+			}
+
+			bool repartition = argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgRepartition]) != argumentMap.end();
+			success = attemptFlash(bridgeManager, fileArray, repartition);
+
+			closeFiles(fileArray);
+			delete [] fileArray;
+
+			break;
+		}
+
+		case InterfaceManager::kActionClosePcScreen:
+		{
+			if (!bridgeManager->BeginSession())
+			{
+				delete bridgeManager;
+				return (-1);
+			}
+
+			InterfaceManager::Print("Attempting to close connect to pc screen...\n");
+			success = bridgeManager->EndSession() && bridgeManager->RebootDevice();
+
+			if (success)
+				InterfaceManager::Print("Attempt complete\n");
+
+			break;
+		}
+
+		case InterfaceManager::kActionDump:
+		{
+			const char *outputFilename = argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgOutput])->second.c_str();
+			FILE *dumpFile = fopen(outputFilename, "wb");
+			if (!dumpFile)
+			{
+				InterfaceManager::PrintError("Failed to open file \"%s\"\n", outputFilename);
+
+				delete bridgeManager;
+				return (-1);
+			}
+
+			int chipType = 0;
+			string chipTypeName = argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipType])->second;
+			if (chipTypeName == "NAND" || chipTypeName == "nand")
+				chipType = 1;
+
+			int chipId = atoi(argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipId])->second.c_str());
+
+			if (!bridgeManager->BeginSession())
+			{
+				fclose(dumpFile);
+
+				delete bridgeManager;
+
+				return (-1);
+			}
+
+			success = bridgeManager->ReceiveDump(chipType, chipId, dumpFile);
+
+			fclose(dumpFile);
+
+			if (success)
+				success = bridgeManager->EndSession() && bridgeManager->RebootDevice();
+
+			break;
+		}
+	}
+
+	delete bridgeManager;
+
+	return ((success) ? 0 : -1);
+}
\ No newline at end of file