33 files changed, 6330 insertions, 1813 deletions

diff --git a/heimdall-frontend/Source/FirmwareInfo.cpp b/heimdall-frontend/Source/FirmwareInfo.cpp
new file mode 100755
index 0000000..7d11605
--- /dev/null
+++ b/heimdall-frontend/Source/FirmwareInfo.cpp
@@ -0,0 +1,571 @@
+/* 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.*/
+
+// Heimdall Frontend
+#include "FirmwareInfo.h"
+
+using namespace HeimdallFrontend;
+
+DeviceInfo::DeviceInfo()
+{
+}
+
+DeviceInfo::DeviceInfo(const QString& manufacturer, const QString& product, const QString& name)
+{
+	this->manufacturer = manufacturer;
+	this->product = product;
+	this->name = name;
+}
+
+bool DeviceInfo::ParseXml(QXmlStreamReader& xml)
+{
+	bool foundManufacturer = false;
+	bool foundProduct = false;
+	bool foundName = false;
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "manufacturer")
+			{
+				if (foundManufacturer)
+				{
+					// TODO: "found multiple device manufacturers."
+					return (false);
+				}
+
+				foundManufacturer = true;
+
+				manufacturer = xml.readElementText();
+			}
+			else if (xml.name() == "product")
+			{
+				if (foundProduct)
+				{
+					// TODO: "found multiple device product identifiers."
+					return (false);
+				}
+
+				foundProduct = true;
+
+				product = xml.readElementText();
+			}
+			else if (xml.name() == "name")
+			{
+				if (foundName)
+				{
+					// TODO: "found multiple device names."));
+					return (false);
+				}
+
+				foundName = true;
+
+				name = xml.readElementText();
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "device")
+				return (foundManufacturer && foundProduct && foundName);
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <device>"
+				return (false);
+			}
+		}
+	}
+
+	return (false);
+}
+
+
+
+PlatformInfo::PlatformInfo()
+{
+}
+
+void PlatformInfo::Clear(void)
+{
+	name.clear();
+	version.clear();
+}
+
+bool PlatformInfo::IsCleared(void) const
+{
+	return (name.isEmpty() && version.isEmpty());
+}
+
+bool PlatformInfo::ParseXml(QXmlStreamReader& xml)
+{
+	Clear();
+
+	bool foundName = false;
+	bool foundVersion = false;
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "name")
+			{
+				if (foundName)
+				{
+					// TODO: "found multiple platform names."
+					return (false);
+				}
+
+				foundName = true;
+
+				name = xml.readElementText();
+			}
+			else if (xml.name() == "version")
+			{
+				if (foundVersion)
+				{
+					// TODO: "found multiple platform versions."
+					return (false);
+				}
+
+				foundVersion = true;
+
+				version = xml.readElementText();
+			}
+			else
+			{
+				// TODO: "found unknown <platform> sub-element <" + xml.name() + ">."
+				return (false);
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "platform")
+				return (foundName && foundVersion);
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <platform>"
+				return (false);
+			}
+		}
+	}
+
+	return (false);
+}
+
+
+
+FileInfo::FileInfo()
+{
+}
+
+FileInfo::FileInfo(unsigned int partitionId, const QString& filename)
+{
+	this->partitionId = partitionId;
+	this->filename = filename;
+}
+
+bool FileInfo::ParseXml(QXmlStreamReader& xml)
+{
+	bool foundId = false;
+	bool foundFilename = false;
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "id")
+			{
+				if (foundId)
+				{
+					// TODO: "found multiple file IDs."
+					return (false);
+				}
+
+				foundId = true;
+
+				partitionId = xml.readElementText().toInt();
+			}
+			else if (xml.name() == "filename")
+			{
+				if (foundFilename)
+				{
+					// TODO: "found multiple file filenames."
+					return (false);
+				}
+
+				foundFilename = true;
+
+				filename = xml.readElementText();
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "file")
+				return (foundId && foundFilename);
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <file>"
+				return (false);
+			}
+		}
+	}
+
+	return (false);
+}
+
+
+
+FirmwareInfo::FirmwareInfo()
+{
+	repartition = false;
+}
+
+void FirmwareInfo::Clear(void)
+{
+	name = "";
+	version = "";
+	platformInfo.Clear();
+
+	developers.clear();
+	url.clear();
+	donateUrl.clear();
+
+	deviceInfos.clear();
+
+	pitFilename.clear();
+	repartition = false;
+
+	fileInfos.clear();
+}
+
+bool FirmwareInfo::IsCleared(void) const
+{
+	return (name.isEmpty() && version.isEmpty() && platformInfo.IsCleared() && developers.isEmpty() && url.isEmpty() && url.isEmpty() && donateUrl.isEmpty()
+		&& deviceInfos.isEmpty() && pitFilename.isEmpty() && !repartition && fileInfos.isEmpty());
+}
+
+bool FirmwareInfo::ParseXml(QXmlStreamReader& xml)
+{
+	Clear();
+
+	bool foundName = false;
+	bool foundVersion = false;
+	bool foundPlatform = false;
+	bool foundDevelopers = false;
+	bool foundUrl = false;
+	bool foundDonateUrl = false;
+	bool foundDevices = false;
+	bool foundPit = false;
+	bool foundRepartition = false;
+	bool foundFiles = false;
+
+	if (!xml.readNextStartElement())
+	{
+		// TODO: "Failed to find <firmware> element."
+		return (false);
+	}
+
+	if (xml.name() != "firmware")
+	{
+		// TODO: "Expected <firmware> element but found <%s>"
+		return (false);
+	}
+
+	QString formatVersionString;
+	formatVersionString += xml.attributes().value("version");
+
+	if (formatVersionString.isEmpty())
+	{
+		// TODO: <firmware> is missing a version."
+		return (false);
+	}
+
+	bool parsedVersion = false;
+	int formatVersion = formatVersionString.toInt(&parsedVersion);
+
+	if (!parsedVersion)
+	{
+		// TODO: "<firmware> contains a malformed version."
+		return (false);
+	}
+
+	if (formatVersion > kVersion)
+	{
+		// TODO: "Package is for a newer version of Heimdall Frontend. Please download the latest version of Heimdall Frontend."
+		return (false);
+	}
+
+	while (!xml.atEnd())
+	{
+		QXmlStreamReader::TokenType nextToken = xml.readNext();
+
+		if (nextToken == QXmlStreamReader::StartElement)
+		{
+			if (xml.name() == "name")
+			{
+				if (foundName)
+				{
+					// TODO: "found multiple firmware names."
+					return (false);
+				}
+
+				foundName = true;
+				name = xml.readElementText();
+			}
+			else if (xml.name() == "version")
+			{
+				if (foundVersion)
+				{
+					// TODO: "found multiple firmware versions."
+					return (false);
+				}
+
+				foundVersion = true;
+				version = xml.readElementText();
+			}
+			else if (xml.name() == "platform")
+			{
+				if (foundPlatform)
+				{
+					// TODO: "found multiple firmware platforms."
+					return (false);
+				}
+
+				foundPlatform = true;
+
+				if (!platformInfo.ParseXml(xml))
+					return (false);
+			}
+			else if (xml.name() == "developers")
+			{
+				if (foundDevelopers)
+				{
+					// TODO: "found multiple sets of firmware developers."
+					return (false);
+				}
+
+				foundDevelopers = true;
+
+				while (!xml.atEnd())
+				{
+					nextToken = xml.readNext();
+
+					if (nextToken == QXmlStreamReader::StartElement)
+					{
+						if (xml.name() == "name")
+							developers.append(xml.readElementText());
+					}
+					else if (nextToken == QXmlStreamReader::EndElement)
+					{
+						if (xml.name() == "developers")
+							break;
+					}
+					else
+					{
+						if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+						{
+							// TODO: "Unexpected token found in <developers>"
+							return (false);
+						}
+					}
+				}
+			}
+			else if (xml.name() == "url")
+			{
+				if (foundUrl)
+				{
+					// TODO: "found multiple firmware URLs."
+					return (false);
+				}
+
+				foundUrl = true;
+
+				url = xml.readElementText();
+			}
+			else if (xml.name() == "donateurl")
+			{
+				if (foundDonateUrl)
+				{
+					// TODO: "found multiple firmware donate URLs."
+					return (false);
+				}
+
+				foundDonateUrl = true;
+
+				donateUrl = xml.readElementText();
+			}
+			else if (xml.name() == "devices")
+			{
+				if (foundDevices)
+				{
+					// TODO: "found multiple sets of firmware devices."
+					return (false);
+				}
+
+				foundDevices = true;
+
+				while (!xml.atEnd())
+				{
+					nextToken = xml.readNext();
+
+					if (nextToken == QXmlStreamReader::StartElement)
+					{
+						if (xml.name() == "device")
+						{
+							DeviceInfo deviceInfo;
+
+							if (!deviceInfo.ParseXml(xml))
+								return (false);
+
+							deviceInfos.append(deviceInfo);
+						}
+					}
+					else if (nextToken == QXmlStreamReader::EndElement)
+					{
+						if (xml.name() == "devices")
+							break;
+					}
+					else
+					{
+						if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+						{
+							// TODO: "Unexpected token found in <devices>"
+							return (false);
+						}
+					}
+				}
+			}
+			else if (xml.name() == "pit")
+			{
+				if (foundPit)
+				{
+					// TODO: "found multiple firmware PIT files."
+					return (false);
+				}
+
+				foundPit = true;
+
+				pitFilename = xml.readElementText();
+			}
+			else if (xml.name() == "repartition")
+			{
+				if (foundRepartition)
+				{
+					// TODO: "found multiple firmware repartition values."
+					return (false);
+				}
+
+				foundRepartition = true;
+
+				repartition = (xml.readElementText().toInt() != 0);
+			}
+			else if (xml.name() == "files")
+			{
+				if (foundFiles)
+				{
+					// TODO: "found multiple sets of firmware files."
+					return (false);
+				}
+
+				foundFiles = true;
+
+				while (!xml.atEnd())
+				{
+					nextToken = xml.readNext();
+
+					if (nextToken == QXmlStreamReader::StartElement)
+					{
+						if (xml.name() == "file")
+						{
+							FileInfo fileInfo;
+
+							if (!fileInfo.ParseXml(xml))
+								return (false);
+
+							fileInfos.append(fileInfo);
+						}
+					}
+					else if (nextToken == QXmlStreamReader::EndElement)
+					{
+						if (xml.name() == "files")
+							break;
+					}
+					else
+					{
+						if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+						{
+							// TODO: "Unexpected token found in <devices>"
+							return (false);
+						}
+					}
+				}
+			}
+			else
+			{
+				// TODO: "unknown <firmware> sub-element <" + xml.name() + ">."
+				return (false);
+			}
+		}
+		else if (nextToken == QXmlStreamReader::EndElement)
+		{
+			if (xml.name() == "firmware")
+			{
+				if (!(foundName && foundVersion && foundPlatform && foundDevelopers && foundDevices && foundPit && foundRepartition && foundFiles))
+					return (false);
+				else
+					break;
+			}
+		}
+		else
+		{
+			if (!(nextToken == QXmlStreamReader::Characters && xml.isWhitespace()))
+			{
+				// TODO: "Unexpected token found in <firmware>"
+				return (false);
+			}
+		}
+	}
+
+	// Read whitespaces at the end of the file (if there are any)
+	xml.readNext();
+
+	if (!xml.atEnd())
+	{
+		// TODO: "Found data after </firmware>"
+		return (false);
+	}
+	
+	return (true);
+}
diff --git a/heimdall-frontend/Source/FirmwareInfo.h b/heimdall-frontend/Source/FirmwareInfo.h
new file mode 100755
index 0000000..a72dab1
--- /dev/null
+++ b/heimdall-frontend/Source/FirmwareInfo.h
@@ -0,0 +1,286 @@
+/* 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.*/
+
+#ifndef FIRMWAREINFO_H
+#define FIRMWAREINFO_H
+
+// Qt
+#include <QFile>
+#include <QString>
+#include <QXmlStreamReader>
+
+namespace HeimdallFrontend
+{
+	class DeviceInfo
+	{		
+		private:
+
+			QString manufacturer;
+			QString product;
+			QString name;
+
+		public:
+
+			DeviceInfo();
+			DeviceInfo(const QString& manufacturer, const QString& product, const QString& name);
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			const QString& GetManufacturer(void) const
+			{
+				return (manufacturer);
+			}
+
+			void SetManufacturer(const QString& manufacturer)
+			{
+				this->manufacturer = manufacturer;
+			}
+
+			const QString& GetProduct(void) const
+			{
+				return (product);
+			}
+
+			void SetProduct(const QString& product)
+			{
+				this->product = product;
+			}
+
+			const QString& GetName(void) const
+			{
+				return (name);
+			}
+
+			void SetName(const QString& name)
+			{
+				this->name = name;
+			}
+	};
+
+	class PlatformInfo
+	{
+		private:
+
+			QString name;
+			QString version;
+
+		public:
+
+			PlatformInfo();
+
+			void Clear(void);
+			bool IsCleared(void) const;
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			const QString& GetName(void) const
+			{
+				return (name);
+			}
+
+			void SetName(const QString& name)
+			{
+				this->name = name;
+			}
+
+			const QString& GetVersion(void) const
+			{
+				return (version);
+			}
+
+			void SetVersion(const QString& version)
+			{
+				this->version = version;
+			}
+	};
+
+	class FileInfo
+	{
+		private:
+
+			unsigned int partitionId;
+			QString filename;
+
+		public:
+
+			FileInfo();
+			FileInfo(unsigned int partitionId, const QString& filename);
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			unsigned int GetPartitionId(void) const
+			{
+				return (partitionId);
+			}
+
+			void SetPartitionId(unsigned int partitionId)
+			{
+				this->partitionId = partitionId;
+			}
+
+			const QString& GetFilename(void) const
+			{
+				return (filename);
+			}
+
+			void SetFilename(const QString& filename)
+			{
+				this->filename = filename;
+			}
+	};
+
+	class FirmwareInfo
+	{
+		public:
+
+			enum
+			{
+				kVersion = 1
+			};
+
+		private:
+
+			QString name;
+			QString version;
+			PlatformInfo platformInfo;
+
+			QList<QString> developers;
+			QString url;
+			QString donateUrl;
+
+			QList<DeviceInfo> deviceInfos;
+
+			QString pitFilename;
+			bool repartition;
+
+			QList<FileInfo> fileInfos;
+
+		public:
+
+			FirmwareInfo();
+
+			void Clear(void);
+			bool IsCleared(void) const;
+
+			bool ParseXml(QXmlStreamReader& xml);
+
+			const QString& GetName(void) const
+			{
+				return (name);
+			}
+
+			void SetName(const QString& name)
+			{
+				this->name = name;
+			}
+
+			const QString& GetVersion(void) const
+			{
+				return (version);
+			}
+
+			void SetVersion(const QString& version)
+			{
+				this->version = version;
+			}
+
+			const PlatformInfo& GetPlatformInfo(void) const
+			{
+				return (platformInfo);
+			}
+
+			PlatformInfo& GetPlatformInfo(void)
+			{
+				return (platformInfo);
+			}
+
+			const QList<QString>& GetDevelopers(void) const
+			{
+				return (developers);
+			}
+
+			QList<QString>& GetDevelopers(void)
+			{
+				return (developers);
+			}
+
+			const QString& GetUrl(void) const
+			{
+				return (url);
+			}
+
+			void SetUrl(const QString& url)
+			{
+				this->url = url;
+			}
+
+			const QString& GetDonateUrl(void) const
+			{
+				return (donateUrl);
+			}
+
+			void SetDonateUrl(const QString& donateUrl)
+			{
+				this->donateUrl = donateUrl;
+			}
+
+			const QList<DeviceInfo>& GetDeviceInfos(void) const
+			{
+				return (deviceInfos);
+			}
+
+			QList<DeviceInfo>& GetDeviceInfos(void)
+			{
+				return (deviceInfos);
+			}
+
+			const QString& GetPitFilename(void) const
+			{
+				return (pitFilename);
+			}
+
+			void SetPitFilename(const QString& pitFilename)
+			{
+				this->pitFilename = pitFilename;
+			}
+
+			bool GetRepartition(void) const
+			{
+				return (repartition);
+			}
+
+			void SetRepartition(bool repartition)
+			{
+				this->repartition = repartition;
+			}
+
+			const QList<FileInfo>& GetFileInfos(void) const
+			{
+				return (fileInfos);
+			}
+
+			QList<FileInfo>& GetFileInfos(void)
+			{
+				return (fileInfos);
+			}
+	};
+}
+
+#endif
diff --git a/heimdall-frontend/Source/PackageData.cpp b/heimdall-frontend/Source/PackageData.cpp
new file mode 100755
index 0000000..36138cf
--- /dev/null
+++ b/heimdall-frontend/Source/PackageData.cpp
@@ -0,0 +1,65 @@
+/* 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.*/
+
+// Heimdall Frontend
+#include "PackageData.h"
+
+using namespace HeimdallFrontend;
+
+PackageData::PackageData()
+{
+}
+
+PackageData::~PackageData()
+{
+	for (int i = 0; i < files.length(); i++)
+		delete files[i];
+}
+
+void PackageData::Clear(void)
+{
+	firmwareInfo.Clear();
+
+	for (int i = 0; i < files.length(); i++)
+		delete files[i];
+
+	files.clear();
+}
+
+bool PackageData::ReadFirmwareInfo(QFile *file)
+{
+	if (!file->open(QFile::ReadOnly))
+	{
+		// TODO: Error
+		return (false);
+	}
+
+	QXmlStreamReader xml(file);
+	bool success = firmwareInfo.ParseXml(xml);
+
+	file->close();
+
+	return (success);
+}
+
+bool PackageData::IsCleared(void) const
+{
+	return (firmwareInfo.IsCleared() && files.isEmpty());
+}
diff --git a/heimdall-frontend/Source/PackageData.h b/heimdall-frontend/Source/PackageData.h
new file mode 100755
index 0000000..9952393
--- /dev/null
+++ b/heimdall-frontend/Source/PackageData.h
@@ -0,0 +1,77 @@
+/* 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.*/
+
+#ifndef PACKAGEDATA_H
+#define PACKAGEDATA_H
+
+// Qt
+#include <QTemporaryFile>
+
+// Heimdall Frontend
+#include "FirmwareInfo.h"
+
+namespace HeimdallFrontend
+{
+	class PackageData
+	{
+		private:
+
+			FirmwareInfo firmwareInfo;
+			QList<QTemporaryFile *> files;
+
+		public:
+
+			PackageData();
+			~PackageData();
+
+			void Clear(void);
+			bool ReadFirmwareInfo(QFile *file);
+
+			bool IsCleared(void) const;
+
+			const FirmwareInfo& GetFirmwareInfo(void) const
+			{
+				return (firmwareInfo);
+			}
+
+			FirmwareInfo& GetFirmwareInfo(void)
+			{
+				return (firmwareInfo);
+			}
+
+			const QList<QTemporaryFile *>& GetFiles(void) const
+			{
+				return (files);
+			}
+
+			QList<QTemporaryFile *>& GetFiles(void)
+			{
+				return (files);
+			}
+
+			// Simply clears the files list, it does delete/close any files.
+			void RemoveAllFiles(void)
+			{
+				files.clear();
+			}
+	};
+}
+
+#endif
diff --git a/heimdall-frontend/Source/Packaging.cpp b/heimdall-frontend/Source/Packaging.cpp
new file mode 100755
index 0000000..cbd03a4
--- /dev/null
+++ b/heimdall-frontend/Source/Packaging.cpp
@@ -0,0 +1,345 @@
+/* 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 <stdio.h>
+
+// zlib
+#include "zlib.h"
+
+// Qt
+#include <QDateTime>
+#include <QDir>
+
+// Heimdall Frontend
+#include "Packaging.h"
+
+using namespace HeimdallFrontend;
+
+const char *Packaging::ustarMagic = "ustar";
+
+bool Packaging::ExtractTar(QTemporaryFile& tarFile, PackageData *outputPackageData)
+{
+	TarHeader tarHeader;
+
+	tarFile.reset();
+
+	bool previousEmpty = false;
+
+	while (!tarFile.atEnd())
+	{
+		qint64 dataRead = tarFile.read(tarHeader.buffer, TarHeader::kBlockLength);
+
+		if (dataRead != TarHeader::kBlockLength)
+			return (false);
+
+		bool ustarFormat = strcmp(tarHeader.fields.magic, ustarMagic) == 0;
+		bool empty = true;
+
+		for (int i = 0; i < TarHeader::kBlockLength; i++)
+		{
+			if (tarHeader.buffer[i] != 0)
+			{
+				empty = false;
+				break;
+			}
+		}
+
+		if (empty)
+		{
+			if (previousEmpty)
+			{
+				// Two empty blocks in a row means we've reached the end of the archive.
+				// TODO: Make sure we're at the end of the file.
+				break;
+			}
+		}
+		else
+		{
+			// TODO: Check checksum
+
+			bool parsed = false;
+		
+			// The size field is not always null terminated, so we must create a copy and null terminate it for parsing.
+			char fileSizeString[13];
+			memcpy(fileSizeString, tarHeader.fields.size, 12);
+			fileSizeString[12] = '\0';
+
+			qulonglong fileSize = QString(fileSizeString).toULongLong(&parsed, 8);
+
+			if (!parsed)
+			{
+				// TODO: Error message?
+				return (false);
+			}
+
+			if (fileSize > 0 && tarHeader.fields.typeFlag == '0')
+			{
+				// We're working with a file.
+				QString filename = QString::fromUtf8(tarHeader.fields.name);
+
+				// This is slightly pointless as we don't support directories...
+				if (ustarFormat)
+					filename.prepend(tarHeader.fields.prefix);
+
+				QTemporaryFile *outputFile = new QTemporaryFile("XXXXXX-" + filename);
+				outputFile->open();
+
+				outputPackageData->GetFiles().append(outputFile);
+
+				qulonglong dataRemaining = fileSize;
+				char readBuffer[TarHeader::kBlockReadCount * TarHeader::kBlockLength];
+
+				// Copy the file contents from tarFile to outputFile
+				while (dataRemaining > 0)
+				{
+					qint64 fileDataToRead = (dataRemaining < TarHeader::kBlockReadCount * TarHeader::kBlockLength)
+						? dataRemaining : TarHeader::kBlockReadCount * TarHeader::kBlockLength;
+
+					qint64 dataRead = tarFile.read(readBuffer, fileDataToRead + (TarHeader::kBlockLength - fileDataToRead % TarHeader::kBlockLength) % TarHeader::kBlockLength);
+
+					if (dataRead < fileDataToRead || dataRead % TarHeader::kBlockLength != 0)
+						return (false);
+
+					outputFile->write(readBuffer, fileDataToRead);
+
+					dataRemaining -= fileDataToRead;
+				}
+
+				outputFile->close();
+			}
+			else
+			{
+				// We don't support links/directories.
+				return (false);
+			}
+		}
+
+		previousEmpty = empty;
+	}
+
+	return (true);
+}
+
+bool Packaging::CreateTar(const PackageData& packageData, QTemporaryFile *outputTarFile)
+{
+	const QList<FileInfo>& fileInfos = packageData.GetFirmwareInfo().GetFileInfos();
+
+	if (!outputTarFile->open())
+	{
+		// TODO: "Failed to open \"%s\""
+		return (false);
+	}
+
+	bool failure = false;
+
+	TarHeader tarHeader;
+
+	for (int i = 0; i < fileInfos.length(); i++)
+	{
+		memset(tarHeader.buffer, 0, TarHeader::kBlockLength);
+
+		QFile file(fileInfos[i].GetFilename());
+
+		if (!file.open(QFile::ReadOnly))
+		{
+			// TODO: "Failed to open \"%s\""
+			failure = true;
+			break;
+		}
+
+		if (file.size() > TarHeader::kMaxFileSize)
+		{
+			// TODO: "File is too large to packaged"
+			failure = true;
+			break;
+		}
+
+		QFileInfo qtFileInfo(file);
+		strcpy(tarHeader.fields.name, qtFileInfo.fileName().toUtf8().constData());
+		
+		unsigned int mode = 0;
+
+		QFile::Permissions permissions = file.permissions();
+
+		// Other
+		if (permissions.testFlag(QFile::ExeOther))
+			mode |= TarHeader::kModeOtherExecute;
+		if (permissions.testFlag(QFile::WriteOther))
+			mode |= TarHeader::kModeOtherWrite;
+		if (permissions.testFlag(QFile::ReadOther))
+			mode |= TarHeader::kModeOtherRead;
+
+		// Group
+		if (permissions.testFlag(QFile::ExeGroup))
+			mode |= TarHeader::kModeGroupExecute;
+		if (permissions.testFlag(QFile::WriteGroup))
+			mode |= TarHeader::kModeGroupWrite;
+		if (permissions.testFlag(QFile::ReadGroup))
+			mode |= TarHeader::kModeGroupRead;
+
+		// Owner
+		if (permissions.testFlag(QFile::ExeOwner))
+			mode |= TarHeader::kModeOwnerExecute;
+		if (permissions.testFlag(QFile::WriteOwner))
+			mode |= TarHeader::kModeOwnerWrite;
+		if (permissions.testFlag(QFile::ReadOwner))
+			mode |= TarHeader::kModeOwnerRead;
+
+		sprintf(tarHeader.fields.mode, "%o", mode);
+
+		sprintf(tarHeader.fields.userId, "%o", qtFileInfo.ownerId());
+		sprintf(tarHeader.fields.groupId, "%o", qtFileInfo.groupId());
+
+		// Note: We don't support base-256 encoding. Support could be added in future.
+		sprintf(tarHeader.fields.size, "%o", file.size());
+
+		sprintf(tarHeader.fields.modifiedTime, "%o", qtFileInfo.lastModified().toMSecsSinceEpoch());
+		
+		// Regular File
+		tarHeader.fields.typeFlag = '0';
+
+		// Calculate checksum
+		int checksum = 0;
+
+		for (int i = 0; i < TarHeader::kTarHeaderLength; i++)
+			checksum += tarHeader.buffer[i];
+
+		sprintf(tarHeader.fields.checksum, "%o", checksum);
+
+		// Write the header to the TAR file.
+		outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+
+		char buffer[TarHeader::kBlockWriteCount * TarHeader::kBlockLength];
+
+		for (qint64 i = 0; i < file.size(); i++)
+		{
+			qint64 dataRead = file.read(buffer, TarHeader::kBlockWriteCount * TarHeader::kBlockLength);
+
+			if (outputTarFile->write(buffer, dataRead) != dataRead)
+			{
+				// TODO: "Failed to write data to the temporary TAR file."
+				failure = true;
+				break;
+			}
+
+			if (dataRead % TarHeader::kBlockLength != 0)
+			{
+				int remainingBlockLength = TarHeader::kBlockLength - dataRead % TarHeader::kBlockLength;
+				memset(buffer, 0, remainingBlockLength);
+
+				if (outputTarFile->write(buffer, remainingBlockLength) != remainingBlockLength)
+				{
+					// TODO: "Failed to write data to the temporary TAR file."
+					failure = true;
+					break;
+				}
+			}
+
+			i += dataRead;
+		}
+
+		if (failure)
+			break;
+	}
+
+	if (failure)
+	{
+		outputTarFile->resize(0);
+		outputTarFile->close();
+		return (false);
+	}
+
+	// Write two empty blocks to signify the end of the archive.
+	memset(tarHeader.buffer, 0, TarHeader::kBlockLength);
+	outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+	outputTarFile->write(tarHeader.buffer, TarHeader::kBlockLength);
+
+	outputTarFile->close();
+
+	return (true);
+}
+
+bool Packaging::ExtractPackage(const QString& packagePath, PackageData *outputPackageData)
+{
+	FILE *compressedPackageFile = fopen(packagePath.toStdString().c_str(), "rb");
+	gzFile packageFile = gzdopen(fileno(compressedPackageFile), "rb");
+
+	QTemporaryFile outputTar("XXXXXX.tar");
+
+	if (!outputTar.open())
+	{
+		gzclose(packageFile);
+
+		return (false);
+	}
+
+	char buffer[32768];
+
+	int bytesRead;
+
+	do
+	{
+		bytesRead = gzread(packageFile, buffer, 32768);
+
+		if (bytesRead == -1)
+		{
+			gzclose(packageFile);
+
+			return (false);
+		}
+
+		outputTar.write(buffer, bytesRead);
+	} while (bytesRead > 0);
+
+	gzclose(packageFile); // Closes packageFile and compressedPackageFile
+
+	if (!ExtractTar(outputTar, outputPackageData))
+		return (false);
+
+	// Find and read firmware.xml
+	for (int i = 0; i < outputPackageData->GetFiles().length(); i++)
+	{
+		QTemporaryFile *file = outputPackageData->GetFiles()[i];
+
+		if (file->fileTemplate() == "XXXXXX-firmware.xml")
+		{
+			if (!outputPackageData->ReadFirmwareInfo(file))
+			{
+				outputPackageData->Clear();
+				return (false);
+			}
+
+			return (true);
+		}
+	}
+
+	return (false);
+}
+
+bool Packaging::BuildPackage(const QString& packagePath, const PackageData& packageData)
+{
+	QTemporaryFile temporaryFile("XXXXXX.tar");
+
+	if (!CreateTar(packageData, &temporaryFile))
+		return (false);
+
+	return (true);
+}
diff --git a/heimdall-frontend/Source/Packaging.h b/heimdall-frontend/Source/Packaging.h
new file mode 100755
index 0000000..c341f0f
--- /dev/null
+++ b/heimdall-frontend/Source/Packaging.h
@@ -0,0 +1,110 @@
+/* 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.*/
+
+#ifndef PACKAGING_H
+#define PACKAGING_H
+
+// Qt
+#include <QList>
+#include <QString>
+#include <QTemporaryFile>
+
+// Heimdall Frontend
+#include "PackageData.h"
+
+namespace HeimdallFrontend
+{
+	union TarHeader
+	{		
+		enum
+		{
+			kBlockLength = 512,
+			kBlockReadCount = 8,
+			kBlockWriteCount = 8,
+
+			kTarHeaderLength = 257,
+			kUstarHeaderLength = 500,
+		};
+
+		enum : quint64
+		{
+			kMaxFileSize = 8589934592
+		};
+
+		enum
+		{
+			kModeOtherExecute = 1,
+			kModeOtherWrite = 1 << 1,
+			kModeOtherRead = 1 << 2,
+
+			kModeGroupExecute = 1 << 3,
+			kModeGroupWrite = 1 << 4,
+			kModeGroupRead = 1 << 5,
+
+			kModeOwnerExecute = 1 << 6,
+			kModeOwnerWrite = 1 << 7,
+			kModeOwnerRead = 1 << 8,
+
+			kModeReserved = 2 << 9,
+			kModeSetGid = 2 << 10,
+			kModeSetUid = 2 << 11		
+		};
+
+		struct
+		{
+			char name[100];
+			char mode[8];
+			char userId[8];
+			char groupId[8];
+			char size[12];
+			char modifiedTime[12];
+			char checksum[8];
+			char typeFlag;
+			char linkName[100];
+			char magic[6];
+			char version[2];
+			char userName[32];
+			char groupName[32];
+			char devMajor[8];
+			char devMinor[8];
+			char prefix[155];
+		} fields;
+
+		char buffer[kBlockLength];
+	};
+
+	class Packaging
+	{
+		private:
+			
+			// TODO: Add support for sparse files to both methods.
+			static bool ExtractTar(QTemporaryFile& tarFile, PackageData *outputPackageData);
+			static bool CreateTar(const PackageData& packageData, QTemporaryFile *outputTarFile); // Uses original TAR format.
+
+		public:
+
+			static const char *ustarMagic;
+
+			static bool ExtractPackage(const QString& packagePath, PackageData *outputPackageData);
+			static bool BuildPackage(const QString& packagePath, const PackageData& packageData);
+	};
+}
+
+#endif
diff --git a/heimdall-frontend/Source/aboutform.cpp b/heimdall-frontend/Source/aboutform.cpp
index f043c20..08b8a3e 100644
--- a/heimdall-frontend/Source/aboutform.cpp
+++ b/heimdall-frontend/Source/aboutform.cpp
@@ -18,7 +18,7 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall

+// Heimdall Frontend

 #include "aboutform.h"

 

 using namespace HeimdallFrontend;

diff --git a/heimdall-frontend/Source/aboutform.h b/heimdall-frontend/Source/aboutform.h
index 2a44c95..7e29136 100644
--- a/heimdall-frontend/Source/aboutform.h
+++ b/heimdall-frontend/Source/aboutform.h
@@ -18,12 +18,12 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall

-#include "ui_aboutform.h"

-

 // Qt

 #include <QWidget>

 

+// Heimdall Frontend

+#include "ui_aboutform.h"

+

 namespace HeimdallFrontend

 {

 	class AboutForm : public QWidget, public Ui::AboutForm

diff --git a/heimdall-frontend/Source/main.cpp b/heimdall-frontend/Source/main.cpp
index 8df987c..9db00f5 100644
--- a/heimdall-frontend/Source/main.cpp
+++ b/heimdall-frontend/Source/main.cpp
@@ -18,20 +18,20 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall Frontend

-#include "mainwindow.h"

-

 // Qt

 #include <QtGui/QApplication>

 

+// Heimdall Frontend

+#include "mainwindow.h"

+

 using namespace HeimdallFrontend;

 

 int main(int argc, char *argv[])

 {

-	QApplication a(argc, argv);

+	QApplication application(argc, argv);

 	

-	MainWindow w;

-	w.show();

+	MainWindow window;

+	window.show();

 

-	return a.exec();

+	return (application.exec());

 }

diff --git a/heimdall-frontend/Source/mainwindow.cpp b/heimdall-frontend/Source/mainwindow.cpp
index b5287e2..8043599 100644
--- a/heimdall-frontend/Source/mainwindow.cpp
+++ b/heimdall-frontend/Source/mainwindow.cpp
@@ -18,9 +18,6 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.*/

 

-// Heimdall Frontend

-#include "mainwindow.h"

-

 // Qt

 #include <QCoreApplication>

 #include <QDesktopServices>

@@ -30,151 +27,214 @@
 #include <QRegExp>

 #include <QUrl>

 

+// Heimdall Frontend

+#include "mainwindow.h"

+#include "Packaging.h"

+

 using namespace HeimdallFrontend;

 

-bool MainWindow::IsArchive(QString path)

+void MainWindow::UpdateUnusedPartitionIds(void)

 {

-	// Not a real check but hopefully it gets the message across, don't flash archives!

-	return (path.endsWith(".tar", Qt::CaseInsensitive) || path.endsWith(".gz", Qt::CaseInsensitive) || path.endsWith(".zip", Qt::CaseInsensitive)

-		|| path.endsWith(".bz2", Qt::CaseInsensitive) || path.endsWith(".7z", Qt::CaseInsensitive) || path.endsWith(".rar", Qt::CaseInsensitive));

+	unusedPartitionIds.clear();

+

+	// Initially populate unusedPartitionIds with all possible partition IDs. 

+	for (unsigned int i = 0; i < currentPitData.GetEntryCount(); i++)

+	{

+		const PitEntry *pitEntry = currentPitData.GetEntry(i);

+

+		if (!pitEntry->GetUnused() && strcmp(pitEntry->GetPartitionName(), "PIT") != 0)

+			unusedPartitionIds.append(pitEntry->GetPartitionIdentifier());

+	}

+

+	// Remove any used partition IDs from unusedPartitionIds

+	QList<FileInfo>& fileList = workingPackageData.GetFirmwareInfo().GetFileInfos();

+

+	for (int i = 0; i < fileList.length(); i++)

+		unusedPartitionIds.removeOne(fileList[i].GetPartitionId());

 }

 

-QString MainWindow::PromptFileSelection(void)

+bool MainWindow::ReadPit(QFile *file)

 {

-	QString path = QFileDialog::getOpenFileName(this, "Select File", lastDirectory);

+	if(!file->open(QIODevice::ReadOnly))

+		return (false);

 

-	if (path != "")

-		lastDirectory = path.left(path.lastIndexOf('/') + 1);

+	unsigned char *buffer = new unsigned char[file->size()];

 

-	return (path);

+	file->read(reinterpret_cast<char *>(buffer), file->size());

+	file->close();

+

+	bool success = currentPitData.Unpack(buffer);

+	delete buffer;

+

+	if (!success)

+		currentPitData.Clear();

+

+	return (success);

 }

 

-void MainWindow::UpdateStartButton(void)

+void MainWindow::UpdatePackageUserInterface(void)

 {

-	if (heimdallRunning)

+	supportedDevicesListWidget->clear();

+	includedFilesListWidget->clear();

+

+	if (loadedPackageData.IsCleared())

 	{

-		startFlashButton->setEnabled(false);

-		return;

-	}

+		// Package Interface

+		firmwareNameLineEdit->clear();

+		versionLineEdit->clear();

 

-	if (repartitionCheckBox->isChecked())

+		developerNamesLineEdit->clear();

+

+		platformLineEdit->clear();

+

+		developerHomepageButton->setEnabled(false);

+		developerDonateButton->setEnabled(false);

+		

+		repartitionRadioButton->setChecked(false);

+

+		loadFirmwareButton->setEnabled(false);

+	}

+	else

 	{

-		if (!IsArchive(pitLineEdit->text()) && factoryfsCheckBox->isChecked() && !IsArchive(factoryfsLineEdit->text()) && kernelCheckBox->isChecked()

-			&& !IsArchive(kernelLineEdit->text()) && paramCheckBox->isChecked() && !IsArchive(paramLineEdit->text())

-			&& primaryBootCheckBox->isChecked() && !IsArchive(primaryBootLineEdit->text()) && secondaryBootCheckBox->isChecked()

-			&& !IsArchive(secondaryBootLineEdit->text()) && modemCheckBox->isChecked() && !IsArchive(modemLineEdit->text()))

+		firmwareNameLineEdit->setText(loadedPackageData.GetFirmwareInfo().GetName());

+		versionLineEdit->setText(loadedPackageData.GetFirmwareInfo().GetVersion());

+

+		QString developerNames;

+

+		if (!loadedPackageData.GetFirmwareInfo().GetDevelopers().isEmpty())

 		{

-			startFlashButton->setEnabled(true);

+			developerNames = loadedPackageData.GetFirmwareInfo().GetDevelopers()[0];

+			for (int i = 1; i < loadedPackageData.GetFirmwareInfo().GetDevelopers().length(); i++)

+				developerNames += ", " + loadedPackageData.GetFirmwareInfo().GetDevelopers()[i];

 		}

+

+		developerNamesLineEdit->setText(developerNames);

+

+		platformLineEdit->setText(loadedPackageData.GetFirmwareInfo().GetPlatformInfo().GetName() + " ("

+			+ loadedPackageData.GetFirmwareInfo().GetPlatformInfo().GetVersion() + ")");

+

+		if (!loadedPackageData.GetFirmwareInfo().GetUrl().isEmpty())

+			developerHomepageButton->setEnabled(true);

 		else

+			developerHomepageButton->setEnabled(false);

+

+		if (!loadedPackageData.GetFirmwareInfo().GetDonateUrl().isEmpty())

+			developerDonateButton->setEnabled(true);

+		else

+			developerDonateButton->setEnabled(false);

+

+		for (int i = 0; i < loadedPackageData.GetFirmwareInfo().GetDeviceInfos().length(); i++)

 		{

-			startFlashButton->setEnabled(false);

+			const DeviceInfo& deviceInfo = loadedPackageData.GetFirmwareInfo().GetDeviceInfos()[i];

+			supportedDevicesListWidget->addItem(deviceInfo.GetManufacturer() + " " + deviceInfo.GetName() + " (" + deviceInfo.GetProduct() + ")");

 		}

-	}

-	else

-	{

-		bool atLeastOneFile = false;

 

-		if (factoryfsCheckBox->isChecked())

+		for (int i = 0; i < loadedPackageData.GetFirmwareInfo().GetFileInfos().length(); i++)

 		{

-			atLeastOneFile = true;

-

-			if (IsArchive(factoryfsLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

+			const FileInfo& fileInfo = loadedPackageData.GetFirmwareInfo().GetFileInfos()[i];

+			includedFilesListWidget->addItem(fileInfo.GetFilename());

 		}

 

-		if (kernelCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+		repartitionRadioButton->setChecked(loadedPackageData.GetFirmwareInfo().GetRepartition());

 

-			if (IsArchive(kernelLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+		loadFirmwareButton->setEnabled(true);

+	}

+}

 

-		if (paramCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+bool MainWindow::IsArchive(QString path)

+{

+	// Not a real check but hopefully it gets the message across, don't flash archives!

+	return (path.endsWith(".tar", Qt::CaseInsensitive) || path.endsWith(".gz", Qt::CaseInsensitive) || path.endsWith(".zip", Qt::CaseInsensitive)

+		|| path.endsWith(".bz2", Qt::CaseInsensitive) || path.endsWith(".7z", Qt::CaseInsensitive) || path.endsWith(".rar", Qt::CaseInsensitive));

+}

 

-			if (IsArchive(paramLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+QString MainWindow::PromptFileSelection(void)

+{

+	QString path = QFileDialog::getOpenFileName(this, "Select File", lastDirectory);

 

-		if (primaryBootCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	if (path != "")

+		lastDirectory = path.left(path.lastIndexOf('/') + 1);

 

-			if (IsArchive(primaryBootLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+	return (path);

+}

 

-		if (secondaryBootCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+QString MainWindow::PromptFileCreation(void)

+{

+	QString path = QFileDialog::getSaveFileName(this, "Save File", lastDirectory);

 

-			if (IsArchive(secondaryBootLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+	if (path != "")

+		lastDirectory = path.left(path.lastIndexOf('/') + 1);

 

-		if (cacheCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	return (path);

+}

 

-			if (IsArchive(cacheLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+void MainWindow::UpdatePartitionNamesInterface(void)

+{

+	populatingPartitionNames = true;

 

-		if (databaseCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	partitionNameComboBox->clear();

 

-			if (IsArchive(databaseLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+	int partitionsListWidgetRow = partitionsListWidget->currentRow();

 

-		if (modemCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+	if (partitionsListWidgetRow >= 0)

+	{

+		const FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[partitionsListWidget->currentRow()];

 

-			if (IsArchive(modemLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

-		}

+		for (int i = 0; i < unusedPartitionIds.length(); i++)

+			partitionNameComboBox->addItem(currentPitData.FindEntry(unusedPartitionIds[i])->GetPartitionName());

 

-		if (recoveryCheckBox->isChecked())

-		{

-			atLeastOneFile = true;

+		partitionNameComboBox->addItem(currentPitData.FindEntry(partitionInfo.GetPartitionId())->GetPartitionName());

+		partitionNameComboBox->setCurrentIndex(unusedPartitionIds.length());

 

-			if (IsArchive(recoveryLineEdit->text()))

-			{

-				startFlashButton->setEnabled(false);

-				return;

-			}

+		partitionNameComboBox->setEnabled(true);

+	}

+	else

+	{

+		partitionNameComboBox->setEnabled(false);

+	}

+

+	populatingPartitionNames = false;

+}

+

+void MainWindow::UpdateStartButton(void)

+{

+	if (heimdallRunning)

+	{

+		startFlashButton->setEnabled(false);

+		return;

+	}

+

+	bool allPartitionsValid = true;

+

+	QList<FileInfo>& fileList = workingPackageData.GetFirmwareInfo().GetFileInfos();

+

+	for (int i = 0; i < fileList.length(); i++)

+	{

+		if (fileList[i].GetFilename().isEmpty())

+		{

+			allPartitionsValid = false;

+			break;

 		}

+	}

+

+	bool validSettings = allPartitionsValid && fileList.length() > 0;

 

-		startFlashButton->setEnabled(atLeastOneFile);

+	startFlashButton->setEnabled(validSettings);

+	functionTabWidget->setTabEnabled(functionTabWidget->indexOf(createPackageTab), validSettings);

+}

+

+void MainWindow::UpdateBuildPackageButton(void)

+{

+	const FirmwareInfo& firmwareInfo = workingPackageData.GetFirmwareInfo();

+

+	if (firmwareInfo.GetName().isEmpty() || firmwareInfo.GetVersion().isEmpty() || firmwareInfo.GetPlatformInfo().GetName().isEmpty()

+		|| firmwareInfo.GetPlatformInfo().GetVersion().isEmpty() || firmwareInfo.GetDevelopers().isEmpty() || firmwareInfo.GetDeviceInfos().isEmpty())

+	{

+		buildPackageButton->setEnabled(false);

+	}

+	else

+	{

+		buildPackageButton->setEnabled(true);

 	}

 }

 

@@ -186,33 +246,52 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
 

 	lastDirectory = QDir::toNativeSeparators(QApplication::applicationDirPath());

 

+	populatingPartitionNames = false;

+

+	functionTabWidget->setTabEnabled(functionTabWidget->indexOf(createPackageTab), false);

+

 	QObject::connect(actionDonate, SIGNAL(triggered()), this, SLOT(OpenDonationWebpage()));

 	QObject::connect(actionAboutHeimdall, SIGNAL(triggered()), this, SLOT(ShowAbout()));

 

+	QObject::connect(browseFirmwarePackageButton, SIGNAL(clicked()), this, SLOT(SelectFirmwarePackage()));

+	QObject::connect(developerHomepageButton, SIGNAL(clicked()), this, SLOT(OpenDeveloperHomepage()));

+	QObject::connect(developerDonateButton, SIGNAL(clicked()), this, SLOT(OpenDeveloperDonationWebpage()));

+	QObject::connect(loadFirmwareButton, SIGNAL(clicked()), this, SLOT(LoadFirmwarePackage()));

+

+	QObject::connect(partitionsListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SelectPartition(int)));

+	QObject::connect(addPartitionButton, SIGNAL(clicked()), this, SLOT(AddPartition()));

+	QObject::connect(removePartitionButton, SIGNAL(clicked()), this, SLOT(RemovePartition()));

+

+	QObject::connect(partitionNameComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(SelectPartitionName(int)));

+	QObject::connect(partitionFileBrowseButton, SIGNAL(clicked()), this, SLOT(SelectPartitionFile()));

+

 	QObject::connect(pitBrowseButton, SIGNAL(clicked()), this, SLOT(SelectPit()));

-	QObject::connect(factoryfsBrowseButton, SIGNAL(clicked()), this, SLOT(SelectFactoryfs()));

-	QObject::connect(kernelBrowseButton, SIGNAL(clicked()), this, SLOT(SelectKernel()));

-	QObject::connect(paramBrowseButton, SIGNAL(clicked()), this, SLOT(SelectParam()));

-	QObject::connect(primaryBootBrowseButton, SIGNAL(clicked()), this, SLOT(SelectPrimaryBootloader()));

-	QObject::connect(secondaryBootBrowseButton, SIGNAL(clicked()), this, SLOT(SelectSecondaryBootloader()));

-	QObject::connect(cacheBrowseButton, SIGNAL(clicked()), this, SLOT(SelectCache()));

-	QObject::connect(databaseBrowseButton, SIGNAL(clicked()), this, SLOT(SelectDatabase()));

-	QObject::connect(modemBrowseButton, SIGNAL(clicked()), this, SLOT(SelectModem()));

-	QObject::connect(recoveryBrowseButton, SIGNAL(clicked()), this, SLOT(SelectRecovery()));

-

-	QObject::connect(repartitionCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetRepartionEnabled(int)));

-	QObject::connect(factoryfsCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetFactoryfsEnabled(int)));

-	QObject::connect(kernelCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetKernelEnabled(int)));

-	QObject::connect(paramCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetParamEnabled(int)));

-	QObject::connect(primaryBootCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetPrimaryBootloaderEnabled(int)));

-	QObject::connect(secondaryBootCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetSecondaryBootloaderEnabled(int)));

-	QObject::connect(cacheCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetCacheEnabled(int)));

-	QObject::connect(databaseCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetDatabaseEnabled(int)));

-	QObject::connect(modemCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetModemEnabled(int)));

-	QObject::connect(recoveryCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetRecoveryEnabled(int)));

+	QObject::connect(repartitionCheckBox, SIGNAL(stateChanged(int)), this, SLOT(SetRepartition(int)));

 	

 	QObject::connect(startFlashButton, SIGNAL(clicked()), this, SLOT(StartFlash()));

 

+	QObject::connect(createFirmwareNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(FirmwareNameChanged(const QString&)));

+	QObject::connect(createFirmwareVersionLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(FirmwareVersionChanged(const QString&)));

+	QObject::connect(createPlatformNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(PlatformNameChanged(const QString&)));

+	QObject::connect(createPlatformVersionLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(PlatformVersionChanged(const QString&)));

+

+	QObject::connect(createHomepageLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(HomepageUrlChanged(const QString&)));

+	QObject::connect(createDonateLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DonateUrlChanged(const QString&)));

+

+	QObject::connect(createDevelopersListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SelectDeveloper(int)));

+	QObject::connect(createDeveloperNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeveloperNameChanged(const QString&)));

+	QObject::connect(addDeveloperButton, SIGNAL(clicked()), this, SLOT(AddDeveloper()));

+	QObject::connect(removeDeveloperButton, SIGNAL(clicked()), this, SLOT(RemoveDeveloper()));

+

+	QObject::connect(createDevicesListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(SelectDevice(int)));

+	QObject::connect(deviceManufacturerLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeviceInfoChanged(const QString&)));

+	QObject::connect(deviceNameLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeviceInfoChanged(const QString&)));

+	QObject::connect(deviceProductCodeLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(DeviceInfoChanged(const QString&)));

+	QObject::connect(addDeviceButton, SIGNAL(clicked()), this, SLOT(AddDevice()));

+	QObject::connect(removeDeviceButton, SIGNAL(clicked()), this, SLOT(RemoveDevice()));

+			

+	QObject::connect(buildPackageButton, SIGNAL(clicked()), this, SLOT(BuildPackage()));

+

 	QObject::connect(&process, SIGNAL(readyRead()), this, SLOT(HandleHeimdallStdout()));

 	QObject::connect(&process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(HandleHeimdallReturned(int, QProcess::ExitStatus)));

 	QObject::connect(&process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(HandleHeimdallError(QProcess::ProcessError)));

@@ -232,284 +311,314 @@ void MainWindow::ShowAbout(void)
 	aboutForm.show();

 }

 

-void MainWindow::SelectPit(void)

+void MainWindow::SelectFirmwarePackage(void)

 {

+	loadedPackageData.Clear();

+	UpdatePackageUserInterface();

+

 	QString path = PromptFileSelection();

-	pitLineEdit->setText(path);

+	firmwarePackageLineEdit->setText(path);

 

-	SetRepartionEnabled(path != "");

+	if (firmwarePackageLineEdit->text() != "")

+	{

+		if (Packaging::ExtractPackage(firmwarePackageLineEdit->text(), &loadedPackageData))

+		{

+			UpdatePackageUserInterface();

+		}

+		else

+		{

+			// TODO: Error?

+			loadedPackageData.Clear();

+		}

+	}

 }

 

-void MainWindow::SelectFactoryfs(void)

+void MainWindow::OpenDeveloperHomepage(void)

 {

-	QString path = PromptFileSelection();

-	factoryfsLineEdit->setText(path);

-

-	SetFactoryfsEnabled(path != "");

+	QDesktopServices::openUrl(QUrl(loadedPackageData.GetFirmwareInfo().GetUrl(), QUrl::TolerantMode));

 }

 

-void MainWindow::SelectKernel(void)

+void MainWindow::OpenDeveloperDonationWebpage(void)

 {

-	QString path = PromptFileSelection();

-	kernelLineEdit->setText(path);

-

-	SetKernelEnabled(path != "");

+	QDesktopServices::openUrl(QUrl(loadedPackageData.GetFirmwareInfo().GetDonateUrl(), QUrl::TolerantMode));

 }

 

-void MainWindow::SelectParam(void)

+void MainWindow::LoadFirmwarePackage(void)

 {

-	QString path = PromptFileSelection();

-	paramLineEdit->setText(path);

+	workingPackageData.Clear();

+	currentPitData.Clear();

+	

+	// Make flashSettings responsible for the temporary files

+	workingPackageData.GetFiles().append(loadedPackageData.GetFiles());

+	loadedPackageData.RemoveAllFiles();

 

-	SetParamEnabled(path != "");

-}

+	const QList<FileInfo> packageFileInfos = loadedPackageData.GetFirmwareInfo().GetFileInfos();

 

-void MainWindow::SelectPrimaryBootloader(void)

-{

-	QString path = PromptFileSelection();

-	primaryBootLineEdit->setText(path);

+	for (int i = 0; i < packageFileInfos.length(); i++)

+	{

+		for (int j = 0; j < workingPackageData.GetFiles().length(); j++)

+		{

+			if (workingPackageData.GetFiles()[j]->fileTemplate() == ("XXXXXX-" + packageFileInfos[i].GetFilename()))

+			{

+				FileInfo partitionInfo(packageFileInfos[i].GetPartitionId(), QDir::current().absoluteFilePath(workingPackageData.GetFiles()[j]->fileName()));

+				workingPackageData.GetFirmwareInfo().GetFileInfos().append(partitionInfo);

 

-	SetPrimaryBootloaderEnabled(path != "");

-}

+				break;

+			}

+		}

+	}

 

-void MainWindow::SelectSecondaryBootloader(void)

-{

-	QString path = PromptFileSelection();

-	secondaryBootLineEdit->setText(path);

+	// Find the PIT file and read it

+	for (int i = 0; i < workingPackageData.GetFiles().length(); i++)

+	{

+		QTemporaryFile *file = workingPackageData.GetFiles()[i];

 

-	SetSecondaryBootloaderEnabled(path != "");

-}

+		if (file->fileTemplate() == ("XXXXXX-" + loadedPackageData.GetFirmwareInfo().GetPitFilename()))

+		{

+			workingPackageData.GetFirmwareInfo().SetPitFilename(QDir::current().absoluteFilePath(file->fileName()));

 

-void MainWindow::SelectCache(void)

-{

-	QString path = PromptFileSelection();

-	cacheLineEdit->setText(path);

+			if (!ReadPit(file))

+			{

+				// TODO: Error

+				loadedPackageData.Clear();

+				UpdatePackageUserInterface();

 

-	SetCacheEnabled(path != "");

-}

+				workingPackageData.Clear();

+				UpdateUnusedPartitionIds();

+				return;

+			}

 

-void MainWindow::SelectDatabase(void)

-{

-	QString path = PromptFileSelection();

-	databaseLineEdit->setText(path);

+			break;

+		}

+	}

 

-	SetDatabaseEnabled(path != "");

-}

+	UpdateUnusedPartitionIds();

+	workingPackageData.GetFirmwareInfo().SetRepartition(loadedPackageData.GetFirmwareInfo().GetRepartition());

 

-void MainWindow::SelectModem(void)

-{

-	QString path = PromptFileSelection();

-	modemLineEdit->setText(path);

+	loadedPackageData.Clear();

+	UpdatePackageUserInterface();

+	firmwarePackageLineEdit->clear();

 

-	SetModemEnabled(path != "");

-}

+	partitionsListWidget->clear();

 

-void MainWindow::SelectRecovery(void)

-{

-	QString path = PromptFileSelection();

-	recoveryLineEdit->setText(path);

+	// Populate partitionsListWidget with partition names (from the PIT file)

+	for (int i = 0; i < workingPackageData.GetFirmwareInfo().GetFileInfos().length(); i++)

+	{

+		const FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[i];

 

-	SetRecoveryEnabled(path != "");

-}

+		const PitEntry *pitEntry = currentPitData.FindEntry(partitionInfo.GetPartitionId());

 

-void MainWindow::SetRepartionEnabled(int enabled)

-{

-	if (repartitionCheckBox->isChecked() != (enabled != 0))

-		repartitionCheckBox->setChecked(enabled);

+		if (pitEntry)

+		{

+			partitionsListWidget->addItem(pitEntry->GetPartitionName());

+		}

+		else

+		{

+			// TODO: "Firmware package includes invalid partition IDs."

+			loadedPackageData.GetFirmwareInfo().Clear();

+			currentPitData.Clear();

+			UpdateUnusedPartitionIds();

 

-	if (enabled)

-	{

-		repartitionCheckBox->setEnabled(true);

-		pitLineEdit->setEnabled(true);

-		repartitionCheckBox->setChecked(true);

-	}

-	else

-	{

-		repartitionCheckBox->setEnabled(pitLineEdit->text() != "");

-		pitLineEdit->setEnabled(false);

+			partitionsListWidget->clear();

+			return;

+		}

 	}

-	

-	UpdateStartButton();

-}

 

-void MainWindow::SetFactoryfsEnabled(int enabled)

-{

-	if (factoryfsCheckBox->isChecked() != (enabled != 0))

-		factoryfsCheckBox->setChecked(enabled);

+	partitionNameComboBox->clear();

+	partitionIdLineEdit->clear();

+	partitionFileLineEdit->clear();

+	partitionFileBrowseButton->setEnabled(false);

 

-	if (enabled)

-	{

-		factoryfsCheckBox->setEnabled(true);

-		factoryfsLineEdit->setEnabled(true);

-		factoryfsCheckBox->setChecked(true);

-	}

-	else

-	{

-		factoryfsCheckBox->setEnabled(factoryfsLineEdit->text() != "");

-		factoryfsLineEdit->setEnabled(false);

-	}

-	

-	UpdateStartButton();

-}

+	repartitionCheckBox->setEnabled(true);

+	repartitionCheckBox->setChecked(workingPackageData.GetFirmwareInfo().GetRepartition());

+	partitionsListWidget->setEnabled(true);

+	addPartitionButton->setEnabled(true);

+	removePartitionButton->setEnabled(true && partitionsListWidget->currentRow() >= 0);

 

-void MainWindow::SetKernelEnabled(int enabled)

-{

-	if (kernelCheckBox->isChecked() != (enabled != 0))

-		kernelCheckBox->setChecked(enabled);

+	pitLineEdit->setText(workingPackageData.GetFirmwareInfo().GetPitFilename());

+

+	functionTabWidget->setCurrentWidget(flashTab);

 

-	if (enabled)

-	{

-		kernelCheckBox->setEnabled(true);

-		kernelLineEdit->setEnabled(true);

-		kernelCheckBox->setChecked(true);

-	}

-	else

-	{

-		kernelCheckBox->setEnabled(kernelLineEdit->text() != "");

-		kernelLineEdit->setEnabled(false);

-	}

-	

 	UpdateStartButton();

 }

 

-void MainWindow::SetParamEnabled(int enabled)

+void MainWindow::SelectPartitionName(int index)

 {

-	if (paramCheckBox->isChecked() != (enabled != 0))

-		paramCheckBox->setChecked(enabled);

-

-	if (enabled)

-	{

-		paramCheckBox->setEnabled(true);

-		paramLineEdit->setEnabled(true);

-		paramCheckBox->setChecked(true);

-	}

-	else

+	if (!populatingPartitionNames && index != -1 && index != unusedPartitionIds.length())

 	{

-		paramCheckBox->setEnabled(paramLineEdit->text() != "");

-		paramLineEdit->setEnabled(false);

+		unsigned int newPartitionIndex = unusedPartitionIds[index];

+		unusedPartitionIds.removeAt(index);

+

+		FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[partitionsListWidget->currentRow()];

+		unusedPartitionIds.append(partitionInfo.GetPartitionId());

+		partitionInfo.SetPartitionId(newPartitionIndex);

+

+		partitionNameComboBox->clear();

+

+		// Update interface

+		UpdatePartitionNamesInterface();

+		partitionIdLineEdit->setText(QString::number(newPartitionIndex));

+		partitionsListWidget->currentItem()->setText(currentPitData.FindEntry(newPartitionIndex)->GetPartitionName());

 	}

-	

-	UpdateStartButton();

 }

 

-void MainWindow::SetPrimaryBootloaderEnabled(int enabled)

+void MainWindow::SelectPartitionFile(void)

 {

-	if (primaryBootCheckBox->isChecked() != (enabled != 0))

-		primaryBootCheckBox->setChecked(enabled);

+	QString path = PromptFileSelection();

 

-	if (enabled)

-	{

-		primaryBootCheckBox->setEnabled(true);

-		primaryBootLineEdit->setEnabled(true);

-		primaryBootCheckBox->setChecked(true);

-	}

-	else

+	if (path != "")

 	{

-		primaryBootCheckBox->setEnabled(primaryBootLineEdit->text() != "");

-		primaryBootLineEdit->setEnabled(false);

+		workingPackageData.GetFirmwareInfo().GetFileInfos()[partitionsListWidget->currentRow()].SetFilename(path);

+		partitionFileLineEdit->setText(path);

+

+		pitBrowseButton->setEnabled(true);

+		partitionsListWidget->setEnabled(true);

+		UpdateStartButton();

+

+		if (unusedPartitionIds.length() > 0)

+			addPartitionButton->setEnabled(true);

 	}

-	

-	UpdateStartButton();

 }

 

-void MainWindow::SetSecondaryBootloaderEnabled(int enabled)

+void MainWindow::SelectPartition(int row)

 {

-	if (secondaryBootCheckBox->isChecked() != (enabled != 0))

-		secondaryBootCheckBox->setChecked(enabled);

-

-	if (enabled)

+	if (row >= 0)

 	{

-		secondaryBootCheckBox->setEnabled(true);

-		secondaryBootLineEdit->setEnabled(true);

-		secondaryBootCheckBox->setChecked(true);

+		const FileInfo& partitionInfo = workingPackageData.GetFirmwareInfo().GetFileInfos()[row];

+

+		UpdatePartitionNamesInterface();

+

+		partitionIdLineEdit->setText(QString::number(partitionInfo.GetPartitionId()));

+		partitionFileLineEdit->setText(partitionInfo.GetFilename());

+		partitionFileBrowseButton->setEnabled(true);

+

+		removePartitionButton->setEnabled(true);

 	}

 	else

 	{

-		secondaryBootCheckBox->setEnabled(secondaryBootLineEdit->text() != "");

-		secondaryBootLineEdit->setEnabled(false);

+		UpdatePartitionNamesInterface();

+

+		partitionIdLineEdit->clear();

+		partitionFileLineEdit->clear();

+		partitionFileBrowseButton->setEnabled(false);

+

+		removePartitionButton->setEnabled(false);

 	}

-	

-	UpdateStartButton();

 }

 

-void MainWindow::SetCacheEnabled(int enabled)

+void MainWindow::AddPartition(void)

 {

-	if (cacheCheckBox->isChecked() != (enabled != 0))

-		cacheCheckBox->setChecked(enabled);

+	FileInfo partitionInfo(unusedPartitionIds.first(), "");

+	workingPackageData.GetFirmwareInfo().GetFileInfos().append(partitionInfo);

+	UpdateUnusedPartitionIds();

 

-	if (enabled)

-	{

-		cacheCheckBox->setEnabled(true);

-		cacheLineEdit->setEnabled(true);

-		cacheCheckBox->setChecked(true);

-	}

-	else

-	{

-		cacheCheckBox->setEnabled(cacheLineEdit->text() != "");

-		cacheLineEdit->setEnabled(false);

-	}

-	

+	pitBrowseButton->setEnabled(false);

+	addPartitionButton->setEnabled(false);

+

+	partitionsListWidget->addItem(currentPitData.FindEntry(partitionInfo.GetPartitionId())->GetPartitionName());

+	partitionsListWidget->setCurrentRow(partitionsListWidget->count() - 1);

+	partitionsListWidget->setEnabled(false);

 	UpdateStartButton();

 }

 

-void MainWindow::SetDatabaseEnabled(int enabled)

+void MainWindow::RemovePartition(void)

 {

-	if (databaseCheckBox->isChecked() != (enabled != 0))

-		databaseCheckBox->setChecked(enabled);

+	workingPackageData.GetFirmwareInfo().GetFileInfos().removeAt(partitionsListWidget->currentRow());

+	UpdateUnusedPartitionIds();

 

-	if (enabled)

-	{

-		databaseCheckBox->setEnabled(true);

-		databaseLineEdit->setEnabled(true);

-		databaseCheckBox->setChecked(true);

-	}

-	else

-	{

-		databaseCheckBox->setEnabled(databaseLineEdit->text() != "");

-		databaseLineEdit->setEnabled(false);

-	}

-	

+	QListWidgetItem *item = partitionsListWidget->currentItem();

+	partitionsListWidget->setCurrentRow(-1);

+	delete item;

+

+	pitBrowseButton->setEnabled(true);

+	addPartitionButton->setEnabled(true);

+	partitionsListWidget->setEnabled(true);

 	UpdateStartButton();

 }

 

-void MainWindow::SetModemEnabled(int enabled)

+void MainWindow::SelectPit(void)

 {

-	if (modemCheckBox->isChecked() != (enabled != 0))

-		modemCheckBox->setChecked(enabled);

+	QString path = PromptFileSelection();

+	bool validPit = path != "";

+

+	// In order to map files in the old PIT to file in the new one, we first must use partition names instead of IDs.

+	QList<FileInfo> fileInfos = workingPackageData.GetFirmwareInfo().GetFileInfos();

+

+	int partitionNamesCount = fileInfos.length();

+	QString *partitionNames = new QString[fileInfos.length()];

+	for (int i = 0; i < fileInfos.length(); i++)

+		partitionNames[i] = currentPitData.FindEntry(fileInfos[i].GetPartitionId())->GetPartitionName();

 

-	if (enabled)

+	currentPitData.Clear();

+

+	if (validPit)

 	{

-		modemCheckBox->setEnabled(true);

-		modemLineEdit->setEnabled(true);

-		modemCheckBox->setChecked(true);

+		QFile pitFile(path);

+

+		if (ReadPit(&pitFile))

+		{

+			workingPackageData.GetFirmwareInfo().SetPitFilename(path);

+

+			partitionsListWidget->clear();

+			int partitionInfoIndex = 0;

+

+			for (int i = 0; i < partitionNamesCount; i++)

+			{

+				const PitEntry *pitEntry = currentPitData.FindEntry(partitionNames[i].toAscii().constData());

+				

+				if (pitEntry)

+				{

+					fileInfos[partitionInfoIndex++].SetPartitionId(pitEntry->GetPartitionIdentifier());

+					partitionsListWidget->addItem(pitEntry->GetPartitionName());

+				}

+				else

+				{

+					fileInfos.removeAt(partitionInfoIndex);

+				}

+			}

+		}

+		else

+		{

+			validPit = false;

+		}

 	}

-	else

+	

+	// If the selected PIT was invalid, attempt to reload the old one.

+	if (!validPit)

 	{

-		modemCheckBox->setEnabled(databaseLineEdit->text() != "");

-		modemLineEdit->setEnabled(false);

+		// TODO: "The file selected was not a valid PIT file."

+		QFile originalPitFile(workingPackageData.GetFirmwareInfo().GetPitFilename());

+

+		if (ReadPit(&originalPitFile))

+		{

+			validPit = true;

+		}

+		else

+		{

+			// TODO: "Failed to reload working PIT data."

+			workingPackageData.Clear();

+			partitionsListWidget->clear();

+		}

 	}

-	

+

+	UpdateUnusedPartitionIds();

+

+	delete [] partitionNames;

+

+	pitLineEdit->setText(workingPackageData.GetFirmwareInfo().GetPitFilename());

+

+	repartitionCheckBox->setEnabled(validPit);

+	partitionsListWidget->setEnabled(validPit);

+

+	addPartitionButton->setEnabled(validPit);

+	removePartitionButton->setEnabled(validPit && partitionsListWidget->currentRow() >= 0);

+

 	UpdateStartButton();

 }

 

-void MainWindow::SetRecoveryEnabled(int enabled)

+void MainWindow::SetRepartition(int enabled)

 {

-	if (recoveryCheckBox->isChecked() != (enabled != 0))

-		recoveryCheckBox->setChecked(enabled);

-

-	if (enabled)

-	{

-		recoveryCheckBox->setEnabled(true);

-		recoveryLineEdit->setEnabled(true);

-		recoveryCheckBox->setChecked(true);

-	}

-	else

-	{

-		recoveryCheckBox->setEnabled(databaseLineEdit->text() != "");

-		recoveryLineEdit->setEnabled(false);

-	}

-	

-	UpdateStartButton();

+	workingPackageData.GetFirmwareInfo().SetRepartition(enabled);

 }

 

 void MainWindow::StartFlash(void)

@@ -522,68 +631,13 @@ void MainWindow::StartFlash(void)
 

 	if (repartitionCheckBox->isChecked())

 	{

+		arguments.append("--repartition");

+

 		arguments.append("--pit");

 		arguments.append(pitLineEdit->text());

 	}

 

-	if (factoryfsCheckBox->isChecked())

-	{

-		arguments.append("--factoryfs");

-		arguments.append(factoryfsLineEdit->text());

-	}

-

-	if (kernelCheckBox->isChecked())

-	{

-		arguments.append("--kernel");

-		arguments.append(kernelLineEdit->text());

-	}

-

-	if (paramCheckBox->isChecked())

-	{

-		arguments.append("--param");

-		arguments.append(paramLineEdit->text());

-	}

-

-	if (primaryBootCheckBox->isChecked())

-	{

-		arguments.append("--primary-boot");

-		arguments.append(primaryBootLineEdit->text());

-	}

-

-	if (secondaryBootCheckBox->isChecked())

-	{

-		arguments.append("--secondary-boot");

-		arguments.append(secondaryBootLineEdit->text());

-	}

-

-	if (cacheCheckBox->isChecked())

-	{

-		arguments.append("--cache");

-		arguments.append(cacheLineEdit->text());

-	}

-

-	if (databaseCheckBox->isChecked())

-	{

-		arguments.append("--dbdata");

-		arguments.append(databaseLineEdit->text());

-	}

-

-	if (modemCheckBox->isChecked())

-	{

-		arguments.append("--modem");

-		arguments.append(modemLineEdit->text());

-	}

-

-	if (recoveryCheckBox->isChecked())

-	{

-		arguments.append("--recovery");

-		arguments.append(recoveryLineEdit->text());

-	}

-

-	if (repartitionCheckBox->isChecked())

-	{

-		arguments.append("--repartition");

-	}

+	// TODO: Loop through partitions and append them.

 

 	flashProgressBar->setEnabled(true);

 	UpdateStartButton();

@@ -600,13 +654,13 @@ void MainWindow::StartFlash(void)
 		QStringList environment = QProcess::systemEnvironment();

 		

 		QStringList paths;

-		// Ensure /usr/local/bin is in PATH

+		// Ensure /usr/bin is in PATH

 		for (int i = 0; i < environment.length(); i++)

 		{

 			if (environment[i].left(5) == "PATH=")

 			{

 				paths = environment[i].mid(5).split(':');

-				paths.prepend("/usr/local/bin");

+				paths.prepend("/usr/bin");

 				break;

 			}

 		}

@@ -640,6 +694,140 @@ void MainWindow::StartFlash(void)
 	}

 }

 

+void MainWindow::FirmwareNameChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetName(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::FirmwareVersionChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetVersion(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::PlatformNameChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().GetPlatformInfo().SetName(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::PlatformVersionChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().GetPlatformInfo().SetVersion(text);

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::HomepageUrlChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetUrl(text);

+}

+

+void MainWindow::DonateUrlChanged(const QString& text)

+{

+	workingPackageData.GetFirmwareInfo().SetDonateUrl(text);

+}

+

+void MainWindow::DeveloperNameChanged(const QString& text)

+{

+	if (text.isEmpty())

+		addDeveloperButton->setEnabled(false);

+	else

+		addDeveloperButton->setEnabled(true);

+}

+

+void MainWindow::SelectDeveloper(int row)

+{

+	if (row >= 0)

+		removeDeveloperButton->setEnabled(true);

+	else

+		removeDeveloperButton->setEnabled(false);

+}

+

+void MainWindow::AddDeveloper(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDevelopers().append(createDeveloperNameLineEdit->text());

+

+	createDevelopersListWidget->addItem(createDeveloperNameLineEdit->text());

+	createDeveloperNameLineEdit->clear();

+

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::RemoveDeveloper(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDevelopers().removeAt(createDevelopersListWidget->currentRow());

+

+	QListWidgetItem *item = createDevelopersListWidget->currentItem();

+	createDevelopersListWidget->setCurrentRow(-1);

+	delete item;

+

+	removeDeveloperButton->setEnabled(false);

+

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::DeviceInfoChanged(const QString& text)

+{

+	if (deviceManufacturerLineEdit->text().isEmpty() || deviceNameLineEdit->text().isEmpty() || deviceProductCodeLineEdit->text().isEmpty())

+		addDeviceButton->setEnabled(false);

+	else

+		addDeviceButton->setEnabled(true);

+}

+

+void MainWindow::SelectDevice(int row)

+{

+	if (row >= 0)

+		removeDeviceButton->setEnabled(true);

+	else

+		removeDeviceButton->setEnabled(false);

+}

+

+void MainWindow::AddDevice(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDeviceInfos().append(DeviceInfo(deviceManufacturerLineEdit->text(), deviceNameLineEdit->text(),

+		deviceProductCodeLineEdit->text()));

+

+	createDevicesListWidget->addItem(deviceManufacturerLineEdit->text() + " " + deviceNameLineEdit->text() + " (" + deviceProductCodeLineEdit->text() + ")");

+	deviceManufacturerLineEdit->clear();

+	deviceNameLineEdit->clear();

+	deviceProductCodeLineEdit->clear();

+

+	UpdateBuildPackageButton();

+}

+

+void MainWindow::RemoveDevice(void)

+{

+	workingPackageData.GetFirmwareInfo().GetDeviceInfos().removeAt(createDevicesListWidget->currentRow());

+

+	QListWidgetItem *item = createDevicesListWidget->currentItem();

+	createDevicesListWidget->setCurrentRow(-1);

+	delete item;

+

+	removeDeviceButton->setEnabled(false);

+

+	UpdateBuildPackageButton();

+}

+			

+void MainWindow::BuildPackage(void)

+{

+	QString packagePath = PromptFileCreation();

+

+	if (!packagePath.endsWith(".tar.gz", Qt::CaseInsensitive))

+	{

+		if (packagePath.endsWith(".tar", Qt::CaseInsensitive))

+			packagePath.append(".gz");

+		else if (packagePath.endsWith(".gz", Qt::CaseInsensitive))

+			packagePath.replace(packagePath.length() - 3, ".tar.gz");

+		else if (packagePath.endsWith(".tgz", Qt::CaseInsensitive))

+			packagePath.replace(packagePath.length() - 4, ".tar.gz");

+		else

+			packagePath.append(".tar.gz");

+	}

+

+	Packaging::BuildPackage(packagePath, workingPackageData);

+}

+

 void MainWindow::HandleHeimdallStdout(void)

 {

 	QString output = process.read(1024);

diff --git a/heimdall-frontend/Source/mainwindow.h b/heimdall-frontend/Source/mainwindow.h
index added4e..7525d67 100644
--- a/heimdall-frontend/Source/mainwindow.h
+++ b/heimdall-frontend/Source/mainwindow.h
@@ -21,13 +21,21 @@
 #ifndef MAINWINDOW_H

 #define MAINWINDOW_H

 

+// Qt

+#include <QList>

+#include <QMainWindow>

+#include <QProcess>

+#include <QTemporaryFile>

+

+// libpit

+#include "libpit.h"

+

 // Heimdall Frontend

 #include "aboutform.h"

 #include "ui_mainwindow.h"

+#include "PackageData.h"

 

-// Qt

-#include <QMainWindow>

-#include <QProcess>

+using namespace libpit;

 

 namespace HeimdallFrontend

 {

@@ -45,11 +53,29 @@ namespace HeimdallFrontend
 			bool heimdallRunning;

 			QProcess process;

 

+			PackageData loadedPackageData;

+			

+			PitData currentPitData;

+			PackageData workingPackageData;

+

+			bool populatingPartitionNames;

+			QList<unsigned int> unusedPartitionIds;

+

+			void UpdateUnusedPartitionIds(void);

+			bool ReadPit(QFile *file);

+

+			void UpdatePackageUserInterface(void);

+

 			bool IsArchive(QString path);

 

 			QString PromptFileSelection(void);

+			QString PromptFileCreation(void);

+

+			void UpdatePartitionNamesInterface(void);

 			void UpdateStartButton(void);

 

+			void UpdateBuildPackageButton(void);

+

 		public:

 

 			explicit MainWindow(QWidget *parent = 0);

@@ -60,30 +86,43 @@ namespace HeimdallFrontend
 			void OpenDonationWebpage(void);

 			void ShowAbout(void);

 

+			void SelectFirmwarePackage(void);

+			void OpenDeveloperHomepage(void);

+			void OpenDeveloperDonationWebpage(void);

+			void LoadFirmwarePackage(void);

+

+			void SelectPartitionName(int index);

+			void SelectPartitionFile(void);

+

+			void SelectPartition(int row);

+			void AddPartition(void);

+			void RemovePartition(void);

+

 			void SelectPit(void);

-			void SelectFactoryfs(void);

-			void SelectKernel(void);

-			void SelectParam(void);

-			void SelectPrimaryBootloader(void);

-			void SelectSecondaryBootloader(void);

-			void SelectCache(void);

-			void SelectDatabase(void);

-			void SelectModem(void);

-			void SelectRecovery(void);

-

-			void SetRepartionEnabled(int enabled);

-			void SetFactoryfsEnabled(int enabled);

-			void SetKernelEnabled(int enabled);

-			void SetParamEnabled(int enabled);

-			void SetPrimaryBootloaderEnabled(int enabled);

-			void SetSecondaryBootloaderEnabled(int enabled);

-			void SetCacheEnabled(int enabled);

-			void SetDatabaseEnabled(int enabled);

-			void SetModemEnabled(int enabled);

-			void SetRecoveryEnabled(int enabled);

+			void SetRepartition(int enabled);

 

 			void StartFlash(void);

 

+			void FirmwareNameChanged(const QString& text);

+			void FirmwareVersionChanged(const QString& text);

+			void PlatformNameChanged(const QString& text);

+			void PlatformVersionChanged(const QString& text);

+

+			void HomepageUrlChanged(const QString& text);

+			void DonateUrlChanged(const QString& text);

+

+			void DeveloperNameChanged(const QString& text);

+			void SelectDeveloper(int row);

+			void AddDeveloper(void);

+			void RemoveDeveloper(void);

+

+			void DeviceInfoChanged(const QString& text);

+			void SelectDevice(int row);

+			void AddDevice(void);

+			void RemoveDevice(void);

+			

+			void BuildPackage(void);

+

 			void HandleHeimdallStdout(void);

 			void HandleHeimdallReturned(int exitCode, QProcess::ExitStatus exitStatus);

 			void HandleHeimdallError(QProcess::ProcessError error);

diff --git a/heimdall-frontend/aboutform.ui b/heimdall-frontend/aboutform.ui
index 80b7181..39e87cc 100644
--- a/heimdall-frontend/aboutform.ui
+++ b/heimdall-frontend/aboutform.ui
@@ -32,7 +32,7 @@
    </size>

   </property>

   <property name="windowTitle">

-   <string>About Heimdall Frontend 1.1</string>

+   <string>About Heimdall Frontend</string>

   </property>

   <widget class="QGroupBox" name="groupBox">

    <property name="geometry">

@@ -50,14 +50,15 @@
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>190</y>

+      <y>160</y>

       <width>581</width>

-      <height>241</height>

+      <height>271</height>

      </rect>

     </property>

     <property name="font">

      <font>

       <pointsize>9</pointsize>

+      <kerning>true</kerning>

      </font>

     </property>

     <property name="autoFillBackground">

@@ -156,21 +157,17 @@ THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRES
       <x>10</x>

       <y>10</y>

       <width>581</width>

-      <height>101</height>

+      <height>51</height>

      </rect>

     </property>

     <property name="font">

      <font>

-      <pointsize>9</pointsize>

+      <pointsize>10</pointsize>

      </font>

     </property>

     <property name="text">

      <string>Heimdall Frontend

-Version 1.1.0

-Copyright © 2010 Benjamin Dobell, Glass Echidna

-

-Heimdall

-Version 1.1.0

+Version 1.3.0

 Copyright © 2010 Benjamin Dobell, Glass Echidna</string>

     </property>

     <property name="textFormat">

@@ -190,7 +187,7 @@ Copyright © 2010 Benjamin Dobell, Glass Echidna</string>
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>118</y>

+      <y>70</y>

       <width>581</width>

       <height>16</height>

      </rect>

@@ -217,7 +214,7 @@ Copyright © 2010 Benjamin Dobell, Glass Echidna</string>
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>130</y>

+      <y>90</y>

       <width>581</width>

       <height>21</height>

      </rect>

@@ -246,7 +243,7 @@ p, li { white-space: pre-wrap; }
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>150</y>

+      <y>110</y>

       <width>581</width>

       <height>16</height>

      </rect>

@@ -273,7 +270,7 @@ p, li { white-space: pre-wrap; }
     <property name="geometry">

      <rect>

       <x>10</x>

-      <y>162</y>

+      <y>130</y>

       <width>581</width>

       <height>21</height>

      </rect>

diff --git a/heimdall-frontend/heimdall-frontend.vcxproj b/heimdall-frontend/heimdall-frontend.vcxproj
index 6182ce6..6844d0a 100644
--- a/heimdall-frontend/heimdall-frontend.vcxproj
+++ b/heimdall-frontend/heimdall-frontend.vcxproj
@@ -62,19 +62,20 @@
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)\</IntDir>

     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(Configuration)\</IntDir>

     <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)\</IntDir>

-    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(IncludePath)</IncludePath>

+    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectDir)include;$(SolutionDir)libpit\Source;$(IncludePath)</IncludePath>

     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>

     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">false</LinkIncremental>

     <IncludePath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(IncludePath)</IncludePath>

     <IncludePath Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(IncludePath)</IncludePath>

     <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(LibraryPath)</LibraryPath>

     <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(LibraryPath)</LibraryPath>

-    <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(LibraryPath)</LibraryPath>

+    <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectDir)lib\win32;$(LibraryPath)</LibraryPath>

+    <SourcePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SourcePath)</SourcePath>

   </PropertyGroup>

   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

     <ClCompile>

       <PreprocessorDefinitions>UNICODE;WIN32;QT_LARGEFILE_SUPPORT;QT_CORE_LIB;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtXml;..\libpit\Source;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <Optimization>Disabled</Optimization>

       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>

       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>

@@ -85,15 +86,15 @@
     <Link>

       <SubSystem>Windows</SubSystem>

       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>

-      <AdditionalLibraryDirectories>$(QTDIR)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

+      <AdditionalLibraryDirectories>$(QTDIR)\lib;$(SolutionDir)$(Platform)\$(Configuration)\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

       <GenerateDebugInformation>true</GenerateDebugInformation>

-      <AdditionalDependencies>qtmaind.lib;QtCored4.lib;QtGuid4.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>qtmaind.lib;QtCored4.lib;QtGuid4.lib;QtXml4.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

     </Link>

   </ItemDefinitionGroup>

   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

     <ClCompile>

       <PreprocessorDefinitions>UNICODE;WIN32;QT_LARGEFILE_SUPPORT;QT_NO_DEBUG;NDEBUG;QT_CORE_LIB;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtXml;..\libpit\Source;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <DebugInformationFormat>

       </DebugInformationFormat>

       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>

@@ -106,15 +107,15 @@
     <Link>

       <SubSystem>Windows</SubSystem>

       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>

-      <AdditionalLibraryDirectories>$(QTDIR)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

+      <AdditionalLibraryDirectories>$(QTDIR)\lib;$(SolutionDir)$(Platform)\$(Configuration)\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

       <GenerateDebugInformation>false</GenerateDebugInformation>

-      <AdditionalDependencies>qtmain.lib;QtCore4.lib;QtGui4.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>qtmain.lib;QtCore4.lib;QtGui4.lib;QtXml4.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

     </Link>

   </ItemDefinitionGroup>

   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">

     <ClCompile>

       <PreprocessorDefinitions>UNICODE;WIN32;QT_LARGEFILE_SUPPORT;QT_NO_DEBUG;NDEBUG;QT_CORE_LIB;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

-      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>.\GeneratedFiles;$(QTDIR)\include;.\GeneratedFiles\$(ConfigurationName);$(QTDIR)\include\qtmain;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtXml;..\libpit\Source;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

       <DebugInformationFormat>

       </DebugInformationFormat>

       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

@@ -127,9 +128,9 @@
     <Link>

       <SubSystem>Windows</SubSystem>

       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>

-      <AdditionalLibraryDirectories>$(QTDIR)\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

+      <AdditionalLibraryDirectories>$(QTDIR)\lib;$(SolutionDir)$(Platform)\$(Configuration)\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>

       <GenerateDebugInformation>false</GenerateDebugInformation>

-      <AdditionalDependencies>qtmains.lib;QtCore4s.lib;QtGui4s.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>qtmains.lib;QtCore4s.lib;QtGui4s.lib;QtXml4s.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

     </Link>

   </ItemDefinitionGroup>

   <ItemGroup>

@@ -147,10 +148,14 @@
     </ClCompile>

     <ClCompile Include="GeneratedFiles\Release\moc_mainwindow.cpp">

       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>

+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">true</ExcludedFromBuild>

     </ClCompile>

     <ClCompile Include="Source\aboutform.cpp" />

+    <ClCompile Include="Source\FirmwareInfo.cpp" />

     <ClCompile Include="Source\main.cpp" />

     <ClCompile Include="Source\mainwindow.cpp" />

+    <ClCompile Include="Source\PackageData.cpp" />

+    <ClCompile Include="Source\Packaging.cpp" />

   </ItemGroup>

   <ItemGroup>

     <CustomBuild Include="mainwindow.ui">

@@ -173,19 +178,22 @@
     <ClInclude Include="GeneratedFiles\ui_aboutform.h" />

     <ClInclude Include="GeneratedFiles\ui_mainwindow.h" />

     <ClInclude Include="Source\aboutform.h" />

+    <ClInclude Include="Source\FirmwareInfo.h" />

+    <ClInclude Include="Source\PackageData.h" />

+    <ClInclude Include="Source\Packaging.h" />

     <CustomBuild Include="Source\mainwindow.h">

       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

       <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Moc%27ing %(Identity)...</Message>

       <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>

-      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_CORE_LIB -DQT_GUI_LIB -D_UNICODE  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I." "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_CORE_LIB -DQT_GUI_LIB -D_UNICODE  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtXml" "-I.\..\libpit\Source" "-I." "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>

       <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Moc%27ing %(Identity)...</Message>

       <Message Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">Moc%27ing %(Identity)...</Message>

       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>

       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>

-      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

-      <Command Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtXml" "-I.\..\libpit\Source" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

+      <Command Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">"$(QTDIR)\bin\moc.exe"   -DUNICODE -DWIN32 -DQT_LARGEFILE_SUPPORT -DQT_NO_DEBUG -DNDEBUG -DQT_CORE_LIB -DQT_GUI_LIB  "-I." "-I.\GeneratedFiles" "-I$(QTDIR)\include" "-I.\GeneratedFiles\$(ConfigurationName)\." "-I$(QTDIR)\include\qtmain" "-I$(QTDIR)\include\QtCore" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtXml" "-I.\..\libpit\Source" "-I." "-I." "-I." "-I." "-I." "Source\mainwindow.h" -o ".\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"</Command>

     </CustomBuild>

   </ItemGroup>

   <ItemGroup>

diff --git a/heimdall-frontend/heimdall-frontend.vcxproj.filters b/heimdall-frontend/heimdall-frontend.vcxproj.filters
index aff2885..d1c227e 100644
--- a/heimdall-frontend/heimdall-frontend.vcxproj.filters
+++ b/heimdall-frontend/heimdall-frontend.vcxproj.filters
@@ -49,6 +49,15 @@
     <ClCompile Include="Source\aboutform.cpp">

       <Filter>Source</Filter>

     </ClCompile>

+    <ClCompile Include="Source\Packaging.cpp">

+      <Filter>Source</Filter>

+    </ClCompile>

+    <ClCompile Include="Source\PackageData.cpp">

+      <Filter>Source</Filter>

+    </ClCompile>

+    <ClCompile Include="Source\FirmwareInfo.cpp">

+      <Filter>Source</Filter>

+    </ClCompile>

   </ItemGroup>

   <ItemGroup>

     <CustomBuild Include="mainwindow.ui">

@@ -74,5 +83,14 @@
     <ClInclude Include="Source\aboutform.h">

       <Filter>Source</Filter>

     </ClInclude>

+    <ClInclude Include="Source\Packaging.h">

+      <Filter>Source</Filter>

+    </ClInclude>

+    <ClInclude Include="Source\PackageData.h">

+      <Filter>Source</Filter>

+    </ClInclude>

+    <ClInclude Include="Source\FirmwareInfo.h">

+      <Filter>Source</Filter>

+    </ClInclude>

   </ItemGroup>

 </Project>
\ No newline at end of file
diff --git a/heimdall-frontend/include/zconf.h b/heimdall-frontend/include/zconf.h
new file mode 100755
index 0000000..02ce56c
--- /dev/null
+++ b/heimdall-frontend/include/zconf.h
@@ -0,0 +1,428 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2010 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+
+/* all linked symbols */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  define gz_error              z_gz_error
+#  define gz_intmax             z_gz_intmax
+#  define gz_strwinerror        z_gz_strwinerror
+#  define gzbuffer              z_gzbuffer
+#  define gzclearerr            z_gzclearerr
+#  define gzclose               z_gzclose
+#  define gzclose_r             z_gzclose_r
+#  define gzclose_w             z_gzclose_w
+#  define gzdirect              z_gzdirect
+#  define gzdopen               z_gzdopen
+#  define gzeof                 z_gzeof
+#  define gzerror               z_gzerror
+#  define gzflush               z_gzflush
+#  define gzgetc                z_gzgetc
+#  define gzgets                z_gzgets
+#  define gzoffset              z_gzoffset
+#  define gzoffset64            z_gzoffset64
+#  define gzopen                z_gzopen
+#  define gzopen64              z_gzopen64
+#  define gzprintf              z_gzprintf
+#  define gzputc                z_gzputc
+#  define gzputs                z_gzputs
+#  define gzread                z_gzread
+#  define gzrewind              z_gzrewind
+#  define gzseek                z_gzseek
+#  define gzseek64              z_gzseek64
+#  define gzsetparams           z_gzsetparams
+#  define gztell                z_gztell
+#  define gztell64              z_gztell64
+#  define gzungetc              z_gzungetc
+#  define gzwrite               z_gzwrite
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  define uncompress            z_uncompress
+#  define zError                z_zError
+#  define zcalloc               z_zcalloc
+#  define zcfree                z_zcfree
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  define gzFile                z_gzFile
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef STDC
+#  include <sys/types.h>    /* for off_t */
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#  include <unistd.h>       /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>     /* for off_t */
+#  endif
+#  ifndef z_off_t
+#    define z_off_t off_t
+#  endif
+#endif
+
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#  define z_off64_t off64_t
+#else
+#  define z_off64_t z_off_t
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/heimdall-frontend/include/zlib.h b/heimdall-frontend/include/zlib.h
new file mode 100755
index 0000000..bfbba83
--- /dev/null
+++ b/heimdall-frontend/include/zlib.h
@@ -0,0 +1,1613 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.5, April 19th, 2010
+
+  Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.5"
+#define ZLIB_VERNUM 0x1250
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 5
+#define ZLIB_VER_SUBREVISION 0
+
+/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip streams in memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use in the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+#define Z_TREES         6
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).  Some
+    output may be provided even if flush is not set.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed code
+  block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error.  After
+  deflate has returned Z_STREAM_END, the only possible operations on the stream
+  are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step.  In this case, avail_out must be at least the
+  value returned by deflateBound (see below).  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  In doubt, the data is considered
+  binary.  This field is only for information purposes and does not affect the
+  compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not
+  fatal, and deflate() can be called again with more input and more output
+  space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  If next_in is not Z_NULL and avail_in is large enough (the
+   exact value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit() does not process any header information -- that is deferred
+   until inflate() is called.
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing will
+    resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all the uncompressed data.  (The size
+  of the uncompressed data may have been saved by the compressor for this
+  purpose.) The next operation on this stream must be inflateEnd to deallocate
+  the decompression state.  The use of Z_FINISH is never required, but can be
+  used to inform inflate that a faster approach may be used for the single
+  inflate() call.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the only effect of the flush parameter in this implementation
+  is on the return value of inflate(), as noted below, or when it returns early
+  because Z_BLOCK or Z_TREES is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the adler32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained, so applications that need that information should
+  instead use raw inflate, see inflateInit2() below, or inflateBack() and
+  perform their own processing of the gzip header and trailer.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent.  In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options.  The
+   fields next_in, zalloc, zfree and opaque must be initialized before by the
+   caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute an adler32 check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to 255 (unknown).  If a
+   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any call
+   of deflate.  The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   adler32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort).  deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.  The
+   stream will keep the same compression level and any other attributes that
+   may have been set by deflateInit2.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression level is changed, the input available so far is
+   compressed with the old level (and may be flushed); the new level will take
+   effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to be
+   compressed and flushed.  In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
+   strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called
+   immediately after inflateInit2() or inflateReset() and before any call of
+   inflate() to set the dictionary.  The application must insure that the
+   dictionary that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect adler32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+     Skips invalid compressed data until a full flush point (see above the
+   description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+   if no more input was provided, Z_DATA_ERROR if no flush point has been
+   found, or Z_STREAM_ERROR if the stream structure was inconsistent.  In the
+   success case, the application may save the current current value of total_in
+   which indicates where valid compressed data was found.  In the error case,
+   the application may repeatedly call inflateSync, providing more input each
+   time, until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
+                                      int windowBits));
+/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+   that this function is used to start inflating at a bit position in the
+   middle of a byte.  The provided bits will be used before any bytes are used
+   from next_in.  This function should only be used with raw inflate, and
+   should be used before the first inflate() call after inflateInit2() or
+   inflateReset().  bits must be less than or equal to 16, and that many of the
+   least significant bits of value will be inserted in the input.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above or -1 << 16 if the provided
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When any
+   of extra, name, or comment are not Z_NULL and the respective field is not
+   present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the paramaters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is more efficient than inflate() for
+   file i/o applications in that it avoids copying between the output and the
+   sliding window by simply making the window itself the output buffer.  This
+   function trusts the application to not change the output buffer passed by
+   the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the normal
+   behavior of inflate(), which expects either a zlib or gzip header and
+   trailer around the deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero--buf is ignored in that
+   case--and inflateBack() will return a buffer error.  inflateBack() will call
+   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
+   should return zero on success, or non-zero on failure.  If out() returns
+   non-zero, inflateBack() will return with an error.  Neither in() nor out()
+   are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.) Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer.  The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer.  Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data.  (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit, destLen
+   is the actual size of the uncompressed buffer.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+                        /* gzip file access functions */
+
+/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+typedef voidp gzFile;       /* opaque gzip file descriptor */
+
+/*
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
+   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
+   for fixed code compression as in "wb9F".  (See the description of
+   deflateInit2 for more information about the strategy parameter.) Also "a"
+   can be used instead of "w" to request that the gzip stream that will be
+   written be appended to the file.  "+" will result in an error, since reading
+   and writing to the same gzip file is not supported.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened.
+*/
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
+   are obtained from calls like open, dup, creat, pipe or fileno (if the file
+   has been previously opened with fopen).  The mode parameter is as in gzopen.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+/*
+     Set the internal buffer size used by this library's functions.  The
+   default buffer size is 8192 bytes.  This function must be called after
+   gzopen() or gzdopen(), and before any other calls that read or write the
+   file.  The buffer memory allocation is always deferred to the first read or
+   write.  Two buffers are allocated, either both of the specified size when
+   writing, or one of the specified size and the other twice that size when
+   reading.  A larger buffer size of, for example, 64K or 128K bytes will
+   noticeably increase the speed of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy.  See the description
+   of deflateInit2 for the meaning of these parameters.
+
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.  If
+   the input file was not in gzip format, gzread copies the given number of
+   bytes into the buffer.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream, or failing that, reading the rest
+   of the input file directly without decompression.  The entire input file
+   will be read if gzread is called until it returns less than the requested
+   len.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.
+*/
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+                                voidpc buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes written or 0 in case of
+   error.
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the arguments to the compressed file under
+   control of the format string, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or 0 in case of error.  The number of
+   uncompressed bytes written is limited to 8191, or one less than the buffer
+   size given to gzbuffer().  The caller should assure that this limit is not
+   exceeded.  If it is exceeded, then gzprintf() will return an error (0) with
+   nothing written.  In this case, there may also be a buffer overflow with
+   unpredictable consequences, which is possible only if zlib was compiled with
+   the insecure functions sprintf() or vsprintf() because the secure snprintf()
+   or vsnprintf() functions were not available.  This can be determined using
+   zlibCompileFlags().
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+     Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+     Reads bytes from the compressed file until len-1 characters are read, or a
+   newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  If any characters are read or if len == 1, the
+   string is terminated with a null character.  If no characters are read due
+   to an end-of-file or len < 1, then the buffer is left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error.  If there was an error, the contents at
+   buf are indeterminate.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+     Writes c, converted to an unsigned char, into the compressed file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+     Push one character back onto the stream to be read as the first character
+   on the next read.  At least one character of push-back is allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file.  The parameter flush
+   is as in the deflate() function.  The return value is the zlib error number
+   (see function gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatented gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                   z_off_t offset, int whence));
+
+     Sets the starting position for the next gzread or gzwrite on the given
+   compressed file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+     Returns the starting position for the next gzread or gzwrite on the given
+   compressed file.  This position represents a number of bytes in the
+   uncompressed data stream, and is zero when starting, even if appending or
+   reading a gzip stream from the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+     Returns the current offset in the file being read or written.  This offset
+   includes the count of bytes that precede the gzip stream, for example when
+   appending or when using gzdopen() for reading.  When reading, the offset
+   does not include as yet unused buffered input.  This information can be used
+   for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns true (1) if the end-of-file indicator has been set while reading,
+   false (0) otherwise.  Note that the end-of-file indicator is set only if the
+   read tried to go past the end of the input, but came up short.  Therefore,
+   just like feof(), gzeof() may return false even if there is no more data to
+   read, in the event that the last read request was for the exact number of
+   bytes remaining in the input file.  This will happen if the input file size
+   is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Returns true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.  This state can change from
+   false to true while reading the input file if the end of a gzip stream is
+   reached, but is followed by data that is not another gzip stream.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file and
+   deallocates the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, or Z_OK on success.
+*/
+
+ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the given
+   compressed file.  errnum is set to zlib error number.  If an error occurred
+   in the file system and not in the compression library, errnum is set to
+   Z_ERRNO and the application may consult errno to get the exact error code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clears the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum.  If buf is Z_NULL, this function returns the
+   required initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32.  If buf is Z_NULL, this function returns the required
+   initial value for the for the crc.  Pre- and post-conditioning (one's
+   complement) is performed within this function so it shouldn't be done by the
+   application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+        inflateBackInit_((strm), (windowBits), (window), \
+                                            ZLIB_VERSION, sizeof(z_stream))
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+#endif
+
+#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0
+#  define gzopen gzopen64
+#  define gzseek gzseek64
+#  define gztell gztell64
+#  define gzoffset gzoffset64
+#  define adler32_combine adler32_combine64
+#  define crc32_combine crc32_combine64
+#  ifdef _LARGEFILE64_SOURCE
+     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#  endif
+#else
+   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif
+
+/* hack for buggy compilers */
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;};
+#endif
+
+/* undocumented functions */
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/heimdall-frontend/lib/win32/zlib.lib b/heimdall-frontend/lib/win32/zlib.lib
new file mode 100755
index 0000000..9da4aeb
--- /dev/null
+++ b/heimdall-frontend/lib/win32/zlib.lib
diff --git a/heimdall-frontend/mainwindow.ui b/heimdall-frontend/mainwindow.ui
index 300be65..6165b8d 100644
--- a/heimdall-frontend/mainwindow.ui
+++ b/heimdall-frontend/mainwindow.ui
@@ -6,8 +6,8 @@
    <rect>

     <x>0</x>

     <y>0</y>

-    <width>902</width>

-    <height>523</height>

+    <width>788</width>

+    <height>505</height>

    </rect>

   </property>

   <property name="sizePolicy">

@@ -18,18 +18,18 @@
   </property>

   <property name="minimumSize">

    <size>

-    <width>902</width>

-    <height>523</height>

+    <width>788</width>

+    <height>505</height>

    </size>

   </property>

   <property name="maximumSize">

    <size>

-    <width>902</width>

-    <height>523</height>

+    <width>788</width>

+    <height>505</height>

    </size>

   </property>

   <property name="windowTitle">

-   <string notr="true">Heimdall Frontend 1.1</string>

+   <string notr="true">Heimdall Frontend</string>

   </property>

   <property name="toolTip">

    <string notr="true"/>

@@ -65,12 +65,15 @@
     </font>

    </property>

    <widget class="QTabWidget" name="functionTabWidget">

+    <property name="enabled">

+     <bool>true</bool>

+    </property>

     <property name="geometry">

      <rect>

-      <x>10</x>

+      <x>5</x>

       <y>0</y>

-      <width>881</width>

-      <height>491</height>

+      <width>780</width>

+      <height>481</height>

      </rect>

     </property>

     <property name="sizePolicy">

@@ -79,161 +82,416 @@
       <verstretch>0</verstretch>

      </sizepolicy>

     </property>

+    <property name="minimumSize">

+     <size>

+      <width>780</width>

+      <height>0</height>

+     </size>

+    </property>

+    <property name="maximumSize">

+     <size>

+      <width>780</width>

+      <height>780</height>

+     </size>

+    </property>

     <property name="currentIndex">

      <number>0</number>

     </property>

+    <property name="usesScrollButtons">

+     <bool>false</bool>

+    </property>

+    <widget class="QWidget" name="loadPackageTab">

+     <attribute name="title">

+      <string>Load Package</string>

+     </attribute>

+     <widget class="QGroupBox" name="includedFilesGroup">

+      <property name="geometry">

+       <rect>

+        <x>510</x>

+        <y>20</y>

+        <width>251</width>

+        <height>341</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Included Files</string>

+      </property>

+      <widget class="QListWidget" name="includedFilesListWidget">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>231</width>

+         <height>311</height>

+        </rect>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="platformGroup">

+      <property name="geometry">

+       <rect>

+        <x>350</x>

+        <y>80</y>

+        <width>151</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Platform</string>

+      </property>

+      <widget class="QLineEdit" name="platformLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>131</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="supportedDevicesGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>220</y>

+        <width>491</width>

+        <height>231</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Supported Devices</string>

+      </property>

+      <widget class="QListWidget" name="supportedDevicesListWidget">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>471</width>

+         <height>201</height>

+        </rect>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QRadioButton" name="repartitionRadioButton">

+      <property name="enabled">

+       <bool>false</bool>

+      </property>

+      <property name="geometry">

+       <rect>

+        <x>520</x>

+        <y>370</y>

+        <width>241</width>

+        <height>21</height>

+       </rect>

+      </property>

+      <property name="text">

+       <string>Repartition Recommended</string>

+      </property>

+     </widget>

+     <widget class="QPushButton" name="loadFirmwareButton">

+      <property name="enabled">

+       <bool>false</bool>

+      </property>

+      <property name="geometry">

+       <rect>

+        <x>580</x>

+        <y>410</y>

+        <width>121</width>

+        <height>31</height>

+       </rect>

+      </property>

+      <property name="text">

+       <string>Load / Customise</string>

+      </property>

+     </widget>

+     <widget class="QGroupBox" name="firmwareNameGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>80</y>

+        <width>221</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Firmware Name</string>

+      </property>

+      <widget class="QLineEdit" name="firmwareNameLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>201</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="firmwarePackageGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>10</y>

+        <width>491</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Heimdall Firmware Package</string>

+      </property>

+      <widget class="QLineEdit" name="firmwarePackageLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>391</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+      <widget class="QPushButton" name="browseFirmwarePackageButton">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>410</x>

+         <y>20</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Browse</string>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="versionGroup">

+      <property name="geometry">

+       <rect>

+        <x>240</x>

+        <y>80</y>

+        <width>101</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Version</string>

+      </property>

+      <widget class="QLineEdit" name="versionLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>81</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="developerGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>150</y>

+        <width>491</width>

+        <height>61</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Developer(s)</string>

+      </property>

+      <widget class="QLineEdit" name="developerNamesLineEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>311</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>true</bool>

+       </property>

+      </widget>

+      <widget class="QPushButton" name="developerDonateButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>410</x>

+         <y>20</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Donate</string>

+       </property>

+      </widget>

+      <widget class="QPushButton" name="developerHomepageButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>330</x>

+         <y>20</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Homepage</string>

+       </property>

+      </widget>

+     </widget>

+    </widget>

     <widget class="QWidget" name="flashTab">

      <attribute name="title">

       <string>Flash</string>

      </attribute>

-     <widget class="QGroupBox" name="pdaGroupBox">

+     <widget class="QGroupBox" name="statusGroup">

       <property name="geometry">

        <rect>

         <x>10</x>

-        <y>120</y>

-        <width>421</width>

-        <height>331</height>

+        <y>290</y>

+        <width>751</width>

+        <height>161</height>

        </rect>

       </property>

       <property name="title">

-       <string>PDA/Code</string>

+       <string>Status</string>

       </property>

-      <widget class="QGroupBox" name="factoryfsGroupBox">

+      <widget class="QProgressBar" name="flashProgressBar">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>320</x>

+         <y>120</y>

+         <width>311</width>

+         <height>31</height>

+        </rect>

+       </property>

+       <property name="value">

+        <number>0</number>

+       </property>

+      </widget>

+      <widget class="QPlainTextEdit" name="outputPlainTextEdit">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>61</height>

+         <width>731</width>

+         <height>91</height>

         </rect>

        </property>

-       <property name="title">

-        <string>FactoryFS</string>

-       </property>

-       <widget class="QLineEdit" name="factoryfsLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="factoryfsBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="factoryfsCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

-      <widget class="QGroupBox" name="kernelGroupBox">

+      <widget class="QLabel" name="flashLabel">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>80</y>

-         <width>401</width>

-         <height>61</height>

+         <y>120</y>

+         <width>301</width>

+         <height>21</height>

         </rect>

        </property>

-       <property name="title">

-        <string>Kernel (zImage)</string>

+       <property name="layoutDirection">

+        <enum>Qt::RightToLeft</enum>

+       </property>

+       <property name="text">

+        <string notr="true">Ready</string>

+       </property>

+       <property name="textFormat">

+        <enum>Qt::PlainText</enum>

+       </property>

+       <property name="alignment">

+        <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>

        </property>

-       <widget class="QLineEdit" name="kernelLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="kernelBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="kernelCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

-      <widget class="QGroupBox" name="primaryBootGroupBox">

+      <widget class="QPushButton" name="startFlashButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>640</x>

+         <y>120</y>

+         <width>91</width>

+         <height>31</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Start</string>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QGroupBox" name="optionsGroup">

+      <property name="geometry">

+       <rect>

+        <x>10</x>

+        <y>10</y>

+        <width>751</width>

+        <height>271</height>

+       </rect>

+      </property>

+      <property name="title">

+       <string>Options</string>

+      </property>

+      <widget class="QGroupBox" name="pitGroup">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>200</y>

-         <width>401</width>

-         <height>61</height>

+         <y>20</y>

+         <width>381</width>

+         <height>91</height>

         </rect>

        </property>

        <property name="title">

-        <string>Primary Bootloader</string>

+        <string>PIT</string>

        </property>

-       <widget class="QLineEdit" name="primaryBootLineEdit">

+       <widget class="QLineEdit" name="pitLineEdit">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>30</x>

-          <y>30</y>

+          <x>10</x>

+          <y>50</y>

           <width>281</width>

           <height>21</height>

          </rect>

@@ -242,11 +500,14 @@
          <bool>true</bool>

         </property>

        </widget>

-       <widget class="QPushButton" name="primaryBootBrowseButton">

+       <widget class="QPushButton" name="pitBrowseButton">

+        <property name="enabled">

+         <bool>true</bool>

+        </property>

         <property name="geometry">

          <rect>

-          <x>320</x>

-          <y>30</y>

+          <x>300</x>

+          <y>50</y>

           <width>71</width>

           <height>23</height>

          </rect>

@@ -255,573 +516,647 @@
          <string>Browse</string>

         </property>

        </widget>

-       <widget class="QCheckBox" name="primaryBootCheckBox">

+       <widget class="QCheckBox" name="repartitionCheckBox">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

           <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

+          <y>20</y>

+          <width>91</width>

+          <height>17</height>

          </rect>

         </property>

         <property name="text">

-         <string/>

+         <string>Repartition</string>

         </property>

        </widget>

       </widget>

-      <widget class="QGroupBox" name="secondaryBootGroupBox">

+      <widget class="QPushButton" name="removePartitionButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>670</x>

+         <y>230</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Remove</string>

+       </property>

+      </widget>

+      <widget class="QGroupBox" name="partitionGroup">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>260</y>

-         <width>401</width>

-         <height>61</height>

+         <y>120</y>

+         <width>381</width>

+         <height>141</height>

         </rect>

        </property>

        <property name="title">

-        <string>Secondary Bootloader</string>

+        <string>File / Partition</string>

        </property>

-       <widget class="QLineEdit" name="secondaryBootLineEdit">

+       <widget class="QComboBox" name="partitionNameComboBox">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

+          <x>110</x>

+          <y>20</y>

+          <width>261</width>

+          <height>22</height>

          </rect>

         </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

        </widget>

-       <widget class="QPushButton" name="secondaryBootBrowseButton">

+       <widget class="QLabel" name="partitionNameLabel">

         <property name="geometry">

          <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

+          <x>10</x>

+          <y>20</y>

+          <width>91</width>

+          <height>16</height>

          </rect>

         </property>

         <property name="text">

-         <string>Browse</string>

+         <string>Partition Name</string>

         </property>

        </widget>

-       <widget class="QCheckBox" name="secondaryBootCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

+       <widget class="QLabel" name="partitionIdLabel">

         <property name="geometry">

          <rect>

           <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

+          <y>50</y>

+          <width>91</width>

+          <height>16</height>

          </rect>

         </property>

         <property name="text">

-         <string/>

+         <string>Partition ID</string>

         </property>

        </widget>

-      </widget>

-      <widget class="QGroupBox" name="paramGroupBox">

-       <property name="geometry">

-        <rect>

-         <x>10</x>

-         <y>140</y>

-         <width>401</width>

-         <height>61</height>

-        </rect>

-       </property>

-       <property name="title">

-        <string>Param.lfs</string>

-       </property>

-       <widget class="QLineEdit" name="paramLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="paramBrowseButton">

+       <widget class="QGroupBox" name="partitionFileGroup">

         <property name="geometry">

          <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

+          <x>10</x>

+          <y>80</y>

+          <width>361</width>

+          <height>51</height>

          </rect>

         </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

+        <property name="title">

+         <string>File</string>

+        </property>

+        <widget class="QLineEdit" name="partitionFileLineEdit">

+         <property name="enabled">

+          <bool>false</bool>

+         </property>

+         <property name="geometry">

+          <rect>

+           <x>10</x>

+           <y>20</y>

+           <width>261</width>

+           <height>21</height>

+          </rect>

+         </property>

+         <property name="readOnly">

+          <bool>true</bool>

+         </property>

+        </widget>

+        <widget class="QPushButton" name="partitionFileBrowseButton">

+         <property name="enabled">

+          <bool>false</bool>

+         </property>

+         <property name="geometry">

+          <rect>

+           <x>280</x>

+           <y>20</y>

+           <width>71</width>

+           <height>23</height>

+          </rect>

+         </property>

+         <property name="text">

+          <string>Browse</string>

+         </property>

+        </widget>

        </widget>

-       <widget class="QCheckBox" name="paramCheckBox">

+       <widget class="QLineEdit" name="partitionIdLineEdit">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

+          <x>110</x>

+          <y>50</y>

+          <width>261</width>

           <height>21</height>

          </rect>

         </property>

-        <property name="text">

-         <string/>

+        <property name="readOnly">

+         <bool>true</bool>

         </property>

        </widget>

       </widget>

+      <widget class="QPushButton" name="addPartitionButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>400</x>

+         <y>230</y>

+         <width>71</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Add</string>

+       </property>

+      </widget>

+      <widget class="QListWidget" name="partitionsListWidget">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>400</x>

+         <y>20</y>

+         <width>341</width>

+         <height>201</height>

+        </rect>

+       </property>

+      </widget>

      </widget>

-     <widget class="QGroupBox" name="cscGroupBox">

+    </widget>

+    <widget class="QWidget" name="createPackageTab">

+     <property name="enabled">

+      <bool>true</bool>

+     </property>

+     <attribute name="title">

+      <string>Create Package</string>

+     </attribute>

+     <widget class="QGroupBox" name="createSupportedDevicesGroup">

       <property name="geometry">

        <rect>

-        <x>440</x>

-        <y>10</y>

-        <width>421</width>

-        <height>151</height>

+        <x>0</x>

+        <y>230</y>

+        <width>491</width>

+        <height>221</height>

        </rect>

       </property>

       <property name="title">

-       <string>CSC</string>

+       <string>Supported Devices</string>

       </property>

-      <widget class="QGroupBox" name="cacheGroupBox">

+      <widget class="QListWidget" name="createDevicesListWidget">

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>61</height>

+         <width>471</width>

+         <height>151</height>

         </rect>

        </property>

-       <property name="title">

-        <string>Cache</string>

-       </property>

-       <widget class="QLineEdit" name="cacheLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="cacheBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="cacheCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

-      <widget class="QGroupBox" name="databaseGroupBox">

+      <widget class="QPushButton" name="removeDeviceButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

        <property name="geometry">

         <rect>

-         <x>10</x>

-         <y>80</y>

-         <width>401</width>

-         <height>61</height>

+         <x>380</x>

+         <y>180</y>

+         <width>101</width>

+         <height>23</height>

         </rect>

        </property>

-       <property name="title">

-        <string>Database Data</string>

+       <property name="text">

+        <string>Remove Device</string>

        </property>

-       <widget class="QLineEdit" name="databaseLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="databaseBrowseButton">

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>30</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="databaseCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string/>

-        </property>

-       </widget>

       </widget>

      </widget>

-     <widget class="QGroupBox" name="repartitionGroupBox">

+     <widget class="QGroupBox" name="createFirmwareVersionGroup">

       <property name="geometry">

        <rect>

-        <x>10</x>

+        <x>240</x>

         <y>10</y>

-        <width>421</width>

-        <height>111</height>

+        <width>111</width>

+        <height>61</height>

        </rect>

       </property>

       <property name="title">

-       <string>Repartition</string>

+       <string>Firmware Version</string>

       </property>

-      <widget class="QGroupBox" name="pitGroupBox">

+      <widget class="QLineEdit" name="createFirmwareVersionLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>81</height>

+         <width>91</width>

+         <height>21</height>

         </rect>

        </property>

-       <property name="title">

-        <string>PIT</string>

+       <property name="readOnly">

+        <bool>false</bool>

        </property>

-       <widget class="QLineEdit" name="pitLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>50</y>

-          <width>301</width>

-          <height>21</height>

-         </rect>

-        </property>

-        <property name="readOnly">

-         <bool>true</bool>

-        </property>

-       </widget>

-       <widget class="QPushButton" name="pitBrowseButton">

-        <property name="enabled">

-         <bool>true</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>320</x>

-          <y>50</y>

-          <width>71</width>

-          <height>23</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Browse</string>

-        </property>

-       </widget>

-       <widget class="QCheckBox" name="repartitionCheckBox">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

-        <property name="geometry">

-         <rect>

-          <x>10</x>

-          <y>20</y>

-          <width>381</width>

-          <height>17</height>

-         </rect>

-        </property>

-        <property name="text">

-         <string>Repartition Device</string>

-        </property>

-       </widget>

       </widget>

      </widget>

-     <widget class="QPushButton" name="startFlashButton">

-      <property name="enabled">

-       <bool>false</bool>

-      </property>

+     <widget class="QGroupBox" name="createPlatformNameGroup">

       <property name="geometry">

        <rect>

-        <x>780</x>

-        <y>410</y>

-        <width>91</width>

-        <height>31</height>

+        <x>490</x>

+        <y>10</y>

+        <width>151</width>

+        <height>61</height>

        </rect>

       </property>

-      <property name="text">

-       <string>Start</string>

+      <property name="title">

+       <string>Platform Name</string>

       </property>

+      <widget class="QLineEdit" name="createPlatformNameLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>131</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

+      </widget>

      </widget>

-     <widget class="QProgressBar" name="flashProgressBar">

-      <property name="enabled">

-       <bool>false</bool>

-      </property>

+     <widget class="QGroupBox" name="createFirmwareNameGroup">

       <property name="geometry">

        <rect>

-        <x>460</x>

-        <y>410</y>

-        <width>311</width>

-        <height>31</height>

+        <x>10</x>

+        <y>10</y>

+        <width>221</width>

+        <height>61</height>

        </rect>

       </property>

-      <property name="value">

-       <number>0</number>

+      <property name="title">

+       <string>Firmware Name</string>

       </property>

+      <widget class="QLineEdit" name="createFirmwareNameLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>201</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

+      </widget>

      </widget>

-     <widget class="QGroupBox" name="otherGroupBox">

+     <widget class="QGroupBox" name="createDevelopersGroup">

       <property name="geometry">

        <rect>

-        <x>440</x>

-        <y>160</y>

-        <width>421</width>

-        <height>151</height>

+        <x>10</x>

+        <y>80</y>

+        <width>751</width>

+        <height>141</height>

        </rect>

       </property>

-      <property name="font">

-       <font>

-        <family>MS Shell Dlg 2</family>

-       </font>

-      </property>

       <property name="title">

-       <string>Other</string>

+       <string>Developers</string>

       </property>

-      <widget class="QGroupBox" name="recoveryGroupBox">

+      <widget class="QListWidget" name="createDevelopersListWidget">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

        <property name="geometry">

         <rect>

-         <x>10</x>

-         <y>80</y>

-         <width>401</width>

-         <height>61</height>

+         <x>550</x>

+         <y>20</y>

+         <width>191</width>

+         <height>81</height>

+        </rect>

+       </property>

+      </widget>

+      <widget class="QGroupBox" name="createDeveloperInfoGroup">

+       <property name="geometry">

+        <rect>

+         <x>300</x>

+         <y>20</y>

+         <width>241</width>

+         <height>101</height>

         </rect>

        </property>

        <property name="title">

-        <string>Recovery</string>

+        <string>Developer Info</string>

        </property>

-       <widget class="QLineEdit" name="recoveryLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

+       <widget class="QLabel" name="createDeveloperNameLabel">

         <property name="geometry">

          <rect>

-          <x>30</x>

+          <x>10</x>

           <y>30</y>

-          <width>281</width>

-          <height>21</height>

+          <width>41</width>

+          <height>16</height>

          </rect>

         </property>

-        <property name="readOnly">

-         <bool>true</bool>

+        <property name="text">

+         <string>Name</string>

         </property>

        </widget>

-       <widget class="QPushButton" name="recoveryBrowseButton">

+       <widget class="QLineEdit" name="createDeveloperNameLineEdit">

+        <property name="enabled">

+         <bool>true</bool>

+        </property>

         <property name="geometry">

          <rect>

-          <x>320</x>

+          <x>60</x>

           <y>30</y>

-          <width>71</width>

-          <height>23</height>

+          <width>171</width>

+          <height>21</height>

          </rect>

         </property>

-        <property name="text">

-         <string>Browse</string>

+        <property name="readOnly">

+         <bool>false</bool>

         </property>

        </widget>

-       <widget class="QCheckBox" name="recoveryCheckBox">

+       <widget class="QPushButton" name="addDeveloperButton">

         <property name="enabled">

          <bool>false</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>10</x>

-          <y>30</y>

-          <width>21</width>

-          <height>21</height>

+          <x>140</x>

+          <y>60</y>

+          <width>91</width>

+          <height>23</height>

          </rect>

         </property>

         <property name="text">

-         <string/>

+         <string>Add Developer</string>

         </property>

        </widget>

       </widget>

-      <widget class="QGroupBox" name="modemGroupBox">

+      <widget class="QPushButton" name="removeDeveloperButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>630</x>

+         <y>110</y>

+         <width>111</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Remove Developer</string>

+       </property>

+      </widget>

+      <widget class="QGroupBox" name="createUrlsGroup">

        <property name="geometry">

         <rect>

          <x>10</x>

          <y>20</y>

-         <width>401</width>

-         <height>61</height>

+         <width>281</width>

+         <height>101</height>

         </rect>

        </property>

        <property name="title">

-        <string>Modem</string>

+        <string>URLs (Optional)</string>

        </property>

-       <widget class="QLineEdit" name="modemLineEdit">

-        <property name="enabled">

-         <bool>false</bool>

-        </property>

+       <widget class="QLabel" name="createDonateLabel">

         <property name="geometry">

          <rect>

-          <x>30</x>

-          <y>30</y>

-          <width>281</width>

-          <height>21</height>

+          <x>10</x>

+          <y>60</y>

+          <width>71</width>

+          <height>16</height>

          </rect>

         </property>

-        <property name="readOnly">

-         <bool>true</bool>

+        <property name="text">

+         <string>Donate</string>

         </property>

        </widget>

-       <widget class="QPushButton" name="modemBrowseButton">

+       <widget class="QLabel" name="createHomepageLabel">

         <property name="geometry">

          <rect>

-          <x>320</x>

+          <x>10</x>

           <y>30</y>

           <width>71</width>

-          <height>23</height>

+          <height>16</height>

          </rect>

         </property>

         <property name="text">

-         <string>Browse</string>

+         <string>Homepage</string>

         </property>

        </widget>

-       <widget class="QCheckBox" name="modemCheckBox">

+       <widget class="QLineEdit" name="createHomepageLineEdit">

         <property name="enabled">

-         <bool>false</bool>

+         <bool>true</bool>

         </property>

         <property name="geometry">

          <rect>

-          <x>10</x>

+          <x>90</x>

           <y>30</y>

-          <width>21</width>

+          <width>181</width>

           <height>21</height>

          </rect>

         </property>

-        <property name="text">

-         <string/>

+        <property name="readOnly">

+         <bool>false</bool>

+        </property>

+       </widget>

+       <widget class="QLineEdit" name="createDonateLineEdit">

+        <property name="enabled">

+         <bool>true</bool>

+        </property>

+        <property name="geometry">

+         <rect>

+          <x>90</x>

+          <y>60</y>

+          <width>181</width>

+          <height>21</height>

+         </rect>

+        </property>

+        <property name="readOnly">

+         <bool>false</bool>

         </property>

        </widget>

       </widget>

      </widget>

-     <widget class="QLabel" name="flashLabel">

+     <widget class="QGroupBox" name="createPlatformVersionGroup">

       <property name="geometry">

        <rect>

-        <x>460</x>

-        <y>380</y>

-        <width>411</width>

-        <height>21</height>

+        <x>650</x>

+        <y>10</y>

+        <width>111</width>

+        <height>61</height>

        </rect>

       </property>

-      <property name="text">

-       <string notr="true">Ready</string>

-      </property>

-      <property name="textFormat">

-       <enum>Qt::PlainText</enum>

-      </property>

-      <property name="alignment">

-       <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>

+      <property name="title">

+       <string>Platform Version</string>

       </property>

+      <widget class="QLineEdit" name="createPlatformVersionLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>91</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

+      </widget>

      </widget>

-    </widget>

-    <widget class="QWidget" name="firmwareTab">

-     <attribute name="title">

-      <string>Download Firmware</string>

-     </attribute>

-     <widget class="QGroupBox" name="groupBox_2">

+     <widget class="QGroupBox" name="createDeviceInfoGroup">

       <property name="geometry">

        <rect>

-        <x>10</x>

-        <y>10</y>

-        <width>851</width>

-        <height>441</height>

+        <x>500</x>

+        <y>250</y>

+        <width>271</width>

+        <height>151</height>

        </rect>

       </property>

       <property name="title">

-       <string/>

+       <string>Device Info</string>

       </property>

-      <widget class="QLabel" name="label">

+      <widget class="QLabel" name="deviceNameLabel">

        <property name="geometry">

         <rect>

          <x>10</x>

-         <y>10</y>

-         <width>831</width>

-         <height>391</height>

+         <y>50</y>

+         <width>91</width>

+         <height>16</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Name</string>

+       </property>

+      </widget>

+      <widget class="QLineEdit" name="deviceNameLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>110</x>

+         <y>50</y>

+         <width>151</width>

+         <height>21</height>

         </rect>

        </property>

-       <property name="frameShape">

-        <enum>QFrame::NoFrame</enum>

+       <property name="readOnly">

+        <bool>false</bool>

        </property>

-       <property name="frameShadow">

-        <enum>QFrame::Plain</enum>

+      </widget>

+      <widget class="QLabel" name="deviceManufacturerLabel">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>20</y>

+         <width>91</width>

+         <height>16</height>

+        </rect>

        </property>

        <property name="text">

-        <string>This functionality is still under development and will be included in a future release.</string>

+        <string>Manufacturer</string>

        </property>

-       <property name="textFormat">

-        <enum>Qt::PlainText</enum>

+      </widget>

+      <widget class="QLineEdit" name="deviceManufacturerLineEdit">

+       <property name="enabled">

+        <bool>true</bool>

        </property>

-       <property name="alignment">

-        <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>

+       <property name="geometry">

+        <rect>

+         <x>110</x>

+         <y>20</y>

+         <width>151</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

        </property>

-       <property name="wordWrap">

+      </widget>

+      <widget class="QLabel" name="productCodeLabel">

+       <property name="geometry">

+        <rect>

+         <x>10</x>

+         <y>80</y>

+         <width>91</width>

+         <height>16</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Product Code</string>

+       </property>

+      </widget>

+      <widget class="QLineEdit" name="deviceProductCodeLineEdit">

+       <property name="enabled">

         <bool>true</bool>

        </property>

+       <property name="geometry">

+        <rect>

+         <x>110</x>

+         <y>80</y>

+         <width>151</width>

+         <height>21</height>

+        </rect>

+       </property>

+       <property name="readOnly">

+        <bool>false</bool>

+       </property>

       </widget>

+      <widget class="QPushButton" name="addDeviceButton">

+       <property name="enabled">

+        <bool>false</bool>

+       </property>

+       <property name="geometry">

+        <rect>

+         <x>160</x>

+         <y>110</y>

+         <width>101</width>

+         <height>23</height>

+        </rect>

+       </property>

+       <property name="text">

+        <string>Add Device</string>

+       </property>

+      </widget>

+     </widget>

+     <widget class="QPushButton" name="buildPackageButton">

+      <property name="enabled">

+       <bool>false</bool>

+      </property>

+      <property name="geometry">

+       <rect>

+        <x>580</x>

+        <y>410</y>

+        <width>121</width>

+        <height>31</height>

+       </rect>

+      </property>

+      <property name="text">

+       <string>Build</string>

+      </property>

      </widget>

     </widget>

    </widget>

@@ -831,7 +1166,7 @@
     <rect>

      <x>0</x>

      <y>0</y>

-     <width>902</width>

+     <width>788</width>

      <height>21</height>

     </rect>

    </property>

@@ -865,8 +1200,57 @@
     <string>Donate to Glass Echidna</string>

    </property>

   </action>

+  <action name="actionPackage_Creation">

+   <property name="text">

+    <string>Package Creation</string>

+   </property>

+  </action>

  </widget>

  <layoutdefault spacing="6" margin="11"/>

+ <tabstops>

+  <tabstop>functionTabWidget</tabstop>

+  <tabstop>firmwarePackageLineEdit</tabstop>

+  <tabstop>browseFirmwarePackageButton</tabstop>

+  <tabstop>firmwareNameLineEdit</tabstop>

+  <tabstop>versionLineEdit</tabstop>

+  <tabstop>platformLineEdit</tabstop>

+  <tabstop>developerNamesLineEdit</tabstop>

+  <tabstop>developerHomepageButton</tabstop>

+  <tabstop>developerDonateButton</tabstop>

+  <tabstop>supportedDevicesListWidget</tabstop>

+  <tabstop>includedFilesListWidget</tabstop>

+  <tabstop>repartitionRadioButton</tabstop>

+  <tabstop>loadFirmwareButton</tabstop>

+  <tabstop>repartitionCheckBox</tabstop>

+  <tabstop>pitLineEdit</tabstop>

+  <tabstop>pitBrowseButton</tabstop>

+  <tabstop>partitionNameComboBox</tabstop>

+  <tabstop>partitionIdLineEdit</tabstop>

+  <tabstop>partitionFileLineEdit</tabstop>

+  <tabstop>partitionFileBrowseButton</tabstop>

+  <tabstop>partitionsListWidget</tabstop>

+  <tabstop>addPartitionButton</tabstop>

+  <tabstop>removePartitionButton</tabstop>

+  <tabstop>outputPlainTextEdit</tabstop>

+  <tabstop>startFlashButton</tabstop>

+  <tabstop>createFirmwareNameLineEdit</tabstop>

+  <tabstop>createFirmwareVersionLineEdit</tabstop>

+  <tabstop>createPlatformNameLineEdit</tabstop>

+  <tabstop>createPlatformVersionLineEdit</tabstop>

+  <tabstop>createHomepageLineEdit</tabstop>

+  <tabstop>createDonateLineEdit</tabstop>

+  <tabstop>createDeveloperNameLineEdit</tabstop>

+  <tabstop>addDeveloperButton</tabstop>

+  <tabstop>createDevelopersListWidget</tabstop>

+  <tabstop>removeDeveloperButton</tabstop>

+  <tabstop>createDevicesListWidget</tabstop>

+  <tabstop>removeDeviceButton</tabstop>

+  <tabstop>deviceManufacturerLineEdit</tabstop>

+  <tabstop>deviceNameLineEdit</tabstop>

+  <tabstop>deviceProductCodeLineEdit</tabstop>

+  <tabstop>addDeviceButton</tabstop>

+  <tabstop>buildPackageButton</tabstop>

+ </tabstops>

  <resources/>

  <connections/>

 </ui>

diff --git a/heimdall/heimdall.vcxproj b/heimdall/heimdall.vcxproj
index ee40753..a0dcc9f 100644
--- a/heimdall/heimdall.vcxproj
+++ b/heimdall/heimdall.vcxproj
@@ -52,19 +52,19 @@
   <PropertyGroup Label="UserMacros" />

   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

     <LinkIncremental>true</LinkIncremental>

-    <IncludePath>$(IncludePath)</IncludePath>

+    <IncludePath>$(SolutionDir)libpit\Source;$(SolutionDir)libusb-1.0\libusb;$(IncludePath)</IncludePath>

     <LibraryPath>$(LibraryPath)</LibraryPath>

     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

   </PropertyGroup>

   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

     <LinkIncremental>false</LinkIncremental>

-    <IncludePath>$(IncludePath)</IncludePath>

+    <IncludePath>$(SolutionDir)libpit\Source;$(SolutionDir)libusb-1.0\libusb;$(IncludePath)</IncludePath>

     <LibraryPath>$(LibraryPath)</LibraryPath>

     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

   </PropertyGroup>

   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">

     <LinkIncremental>false</LinkIncremental>

-    <IncludePath>$(IncludePath)</IncludePath>

+    <IncludePath>$(SolutionDir)libpit\Source;$(SolutionDir)libusb-1.0\libusb;$(IncludePath)</IncludePath>

     <LibraryPath>$(LibraryPath)</LibraryPath>

     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>

   </PropertyGroup>

@@ -79,12 +79,12 @@
       </PrecompiledHeaderFile>

       <PrecompiledHeaderOutputFile>

       </PrecompiledHeaderOutputFile>

-      <AdditionalIncludeDirectories>..\libusb-1.0\libusb</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>..\libusb-1.0\libusb;..\libpit\Source</AdditionalIncludeDirectories>

     </ClCompile>

     <Link>

       <SubSystem>Console</SubSystem>

       <GenerateDebugInformation>true</GenerateDebugInformation>

-      <AdditionalDependencies>libusb-1.0.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>libusb-1.0.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

       <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)\lib\</AdditionalLibraryDirectories>

     </Link>

   </ItemDefinitionGroup>

@@ -101,14 +101,14 @@
       </PrecompiledHeaderFile>

       <PrecompiledHeaderOutputFile>

       </PrecompiledHeaderOutputFile>

-      <AdditionalIncludeDirectories>..\libusb-1.0\libusb</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>..\libusb-1.0\libusb;..\libpit\Source</AdditionalIncludeDirectories>

     </ClCompile>

     <Link>

       <SubSystem>Console</SubSystem>

       <GenerateDebugInformation>true</GenerateDebugInformation>

       <EnableCOMDATFolding>true</EnableCOMDATFolding>

       <OptimizeReferences>true</OptimizeReferences>

-      <AdditionalDependencies>libusb-1.0.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>libusb-1.0.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

       <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)\lib\</AdditionalLibraryDirectories>

     </Link>

   </ItemDefinitionGroup>

@@ -125,14 +125,14 @@
       </PrecompiledHeaderFile>

       <PrecompiledHeaderOutputFile>

       </PrecompiledHeaderOutputFile>

-      <AdditionalIncludeDirectories>..\libusb-1.0\libusb</AdditionalIncludeDirectories>

+      <AdditionalIncludeDirectories>..\libusb-1.0\libusb;..\libpit\Source</AdditionalIncludeDirectories>

     </ClCompile>

     <Link>

       <SubSystem>Console</SubSystem>

       <GenerateDebugInformation>true</GenerateDebugInformation>

       <EnableCOMDATFolding>true</EnableCOMDATFolding>

       <OptimizeReferences>true</OptimizeReferences>

-      <AdditionalDependencies>libusb-1.0.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <AdditionalDependencies>libusb-1.0.lib;libpit.lib;%(AdditionalDependencies)</AdditionalDependencies>

       <AdditionalLibraryDirectories>$(SolutionDir)$(Platform)\$(Configuration)\lib\</AdditionalLibraryDirectories>

     </Link>

   </ItemDefinitionGroup>

@@ -153,10 +153,9 @@
     <ClInclude Include="source\FlashPartPitFilePacket.h" />

     <ClInclude Include="source\Heimdall.h" />

     <ClInclude Include="source\InboundPacket.h" />

-    <ClInclude Include="source\InterfaceManager.h" />

+    <ClInclude Include="source\Interface.h" />

     <ClInclude Include="source\OutboundPacket.h" />

     <ClInclude Include="source\Packet.h" />

-    <ClInclude Include="source\PitData.h" />

     <ClInclude Include="source\PitFilePacket.h" />

     <ClInclude Include="source\PitFileResponse.h" />

     <ClInclude Include="source\EndSessionPacket.h" />

@@ -167,9 +166,8 @@
   </ItemGroup>

   <ItemGroup>

     <ClCompile Include="source\BridgeManager.cpp" />

-    <ClCompile Include="source\InterfaceManager.cpp" />

+    <ClCompile Include="source\Interface.cpp" />

     <ClCompile Include="source\main.cpp" />

-    <ClCompile Include="source\PitData.cpp" />

   </ItemGroup>

   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

   <ImportGroup Label="ExtensionTargets">

diff --git a/heimdall/heimdall.vcxproj.filters b/heimdall/heimdall.vcxproj.filters
index 737c921..e89df24 100644
--- a/heimdall/heimdall.vcxproj.filters
+++ b/heimdall/heimdall.vcxproj.filters
@@ -79,13 +79,10 @@
     <ClInclude Include="source\SendFilePartResponse.h">

       <Filter>Source</Filter>

     </ClInclude>

-    <ClInclude Include="source\InterfaceManager.h">

-      <Filter>Source</Filter>

-    </ClInclude>

-    <ClInclude Include="source\PitData.h">

+    <ClInclude Include="source\EndSessionPacket.h">

       <Filter>Source</Filter>

     </ClInclude>

-    <ClInclude Include="source\EndSessionPacket.h">

+    <ClInclude Include="source\Interface.h">

       <Filter>Source</Filter>

     </ClInclude>

   </ItemGroup>

@@ -96,10 +93,7 @@
     <ClCompile Include="source\main.cpp">

       <Filter>Source</Filter>

     </ClCompile>

-    <ClCompile Include="source\InterfaceManager.cpp">

-      <Filter>Source</Filter>

-    </ClCompile>

-    <ClCompile Include="source\PitData.cpp">

+    <ClCompile Include="source\Interface.cpp">

       <Filter>Source</Filter>

     </ClCompile>

   </ItemGroup>

diff --git a/heimdall/source/BridgeManager.cpp b/heimdall/source/BridgeManager.cpp
index caa3978..204d87f 100644
--- a/heimdall/source/BridgeManager.cpp
+++ b/heimdall/source/BridgeManager.cpp
@@ -27,6 +27,8 @@
 // Heimdall
 #include "BeginDumpPacket.h"
 #include "BridgeManager.h"
+#include "DeviceInfoPacket.h"
+#include "DeviceInfoResponse.h"
 #include "DumpPartFileTransferPacket.h"
 #include "DumpPartPitFilePacket.h"
 #include "DumpResponse.h"
@@ -37,7 +39,7 @@
 #include "FlashPartFileTransferPacket.h"
 #include "FlashPartPitFilePacket.h"
 #include "InboundPacket.h"
-#include "InterfaceManager.h"
+#include "Interface.h"
 #include "OutboundPacket.h"
 #include "PitFilePacket.h"
 #include "PitFileResponse.h"
@@ -92,7 +94,7 @@ BridgeManager::~BridgeManager()
 
 	if (detachedDriver)
 	{
-		InterfaceManager::Print("Re-attaching kernel driver...\n");
+		Interface::Print("Re-attaching kernel driver...\n");
 		libusb_attach_kernel_driver(deviceHandle, interfaceIndex);
 	}
 
@@ -108,13 +110,50 @@ BridgeManager::~BridgeManager()
 		libusb_exit(libusbContext);
 }
 
+bool BridgeManager::DetectDevice(void)
+{
+	// Initialise libusb-1.0
+	int result = libusb_init(&libusbContext);
+	if (result != LIBUSB_SUCCESS)
+	{
+		Interface::PrintError("Failed to initialise libusb. Error: %i\n", result);
+		return (false);
+	}
+
+	// Get handle to Galaxy S device
+	struct libusb_device **devices;
+	int deviceCount = libusb_get_device_list(libusbContext, &devices);
+
+	for (int deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++)
+	{
+		libusb_device_descriptor descriptor;
+		libusb_get_device_descriptor(devices[deviceIndex], &descriptor);
+
+		for (int i = 0; i < BridgeManager::kSupportedDeviceCount; i++)
+		{
+			if (descriptor.idVendor == supportedDevices[i].vendorId && descriptor.idProduct == supportedDevices[i].productId)
+			{
+				libusb_free_device_list(devices, deviceCount);
+
+				Interface::Print("Device detected");
+				return (true);
+			}
+		}
+	}
+
+	libusb_free_device_list(devices, deviceCount);
+
+	Interface::Print("Failed to detect compatible device\n");
+	return (false);
+}
+
 bool BridgeManager::Initialise(void)
 {
 	// Initialise libusb-1.0
 	int result = libusb_init(&libusbContext);
 	if (result != LIBUSB_SUCCESS)
 	{
-		InterfaceManager::PrintError("Failed to initialise libusb. Error: %i\n", result);
+		Interface::PrintError("Failed to initialise libusb. Error: %i\n", result);
 		return (false);
 	}
 
@@ -145,14 +184,14 @@ bool BridgeManager::Initialise(void)
 
 	if (!heimdallDevice)
 	{
-		InterfaceManager::PrintError("Failed to detect compatible device\n");
+		Interface::PrintError("Failed to detect compatible device\n");
 		return (false);
 	}
 
 	result = libusb_open(heimdallDevice, &deviceHandle);
 	if (result != LIBUSB_SUCCESS)
 	{
-		InterfaceManager::PrintError("Failed to access device. Error: %i\n", result);
+		Interface::PrintError("Failed to access device. Error: %i\n", result);
 		return (false);
 	}
 
@@ -160,7 +199,7 @@ bool BridgeManager::Initialise(void)
 	result = libusb_get_device_descriptor(heimdallDevice, &deviceDescriptor);
 	if (result != LIBUSB_SUCCESS)
 	{
-		InterfaceManager::PrintError("Failed to retrieve device description\n");
+		Interface::PrintError("Failed to retrieve device description\n");
 		return (false);
 	}
 
@@ -170,36 +209,36 @@ bool BridgeManager::Initialise(void)
 		if (libusb_get_string_descriptor_ascii(deviceHandle, deviceDescriptor.iManufacturer,
 			stringBuffer, 128) >= 0)
 		{
-			InterfaceManager::Print("      Manufacturer: \"%s\"\n", stringBuffer);
+			Interface::Print("      Manufacturer: \"%s\"\n", stringBuffer);
 		}
 
 		if (libusb_get_string_descriptor_ascii(deviceHandle, deviceDescriptor.iProduct,
 			stringBuffer, 128) >= 0)
 		{
-			InterfaceManager::Print("           Product: \"%s\"\n", stringBuffer);
+			Interface::Print("           Product: \"%s\"\n", stringBuffer);
 		}
 
 		if (libusb_get_string_descriptor_ascii(deviceHandle, deviceDescriptor.iSerialNumber,
 			stringBuffer, 128) >= 0)
 		{
-			InterfaceManager::Print("         Serial No: \"%s\"\n", stringBuffer);
+			Interface::Print("         Serial No: \"%s\"\n", stringBuffer);
 		}
 
-		InterfaceManager::Print("\n            length: %d\n", deviceDescriptor.bLength);
-		InterfaceManager::Print("      device class: %d\n", deviceDescriptor.bDeviceClass);
-		InterfaceManager::Print("               S/N: %d\n", deviceDescriptor.iSerialNumber);
-		InterfaceManager::Print("           VID:PID: %04X:%04X\n", deviceDescriptor.idVendor, deviceDescriptor.idProduct);
-		InterfaceManager::Print("         bcdDevice: %04X\n", deviceDescriptor.bcdDevice);
-		InterfaceManager::Print("   iMan:iProd:iSer: %d:%d:%d\n", deviceDescriptor.iManufacturer, deviceDescriptor.iProduct,
+		Interface::Print("\n            length: %d\n", deviceDescriptor.bLength);
+		Interface::Print("      device class: %d\n", deviceDescriptor.bDeviceClass);
+		Interface::Print("               S/N: %d\n", deviceDescriptor.iSerialNumber);
+		Interface::Print("           VID:PID: %04X:%04X\n", deviceDescriptor.idVendor, deviceDescriptor.idProduct);
+		Interface::Print("         bcdDevice: %04X\n", deviceDescriptor.bcdDevice);
+		Interface::Print("   iMan:iProd:iSer: %d:%d:%d\n", deviceDescriptor.iManufacturer, deviceDescriptor.iProduct,
 			deviceDescriptor.iSerialNumber);
-		InterfaceManager::Print("          nb confs: %d\n", deviceDescriptor.bNumConfigurations);
+		Interface::Print("          nb confs: %d\n", deviceDescriptor.bNumConfigurations);
 	}
 
 	libusb_config_descriptor *configDescriptor;
 	result = libusb_get_config_descriptor(heimdallDevice, 0, &configDescriptor);
 	if (result != LIBUSB_SUCCESS || !configDescriptor)
 	{
-		InterfaceManager::PrintError("Failed to retrieve config descriptor\n");
+		Interface::PrintError("Failed to retrieve config descriptor\n");
 		return (false);
 	}
 
@@ -212,9 +251,9 @@ bool BridgeManager::Initialise(void)
 		{
 			if (verbose)
 			{
-				InterfaceManager::Print("\ninterface[%d].altsetting[%d]: num endpoints = %d\n",
+				Interface::Print("\ninterface[%d].altsetting[%d]: num endpoints = %d\n",
 					i, j, configDescriptor->usb_interface[i].altsetting[j].bNumEndpoints);
-				InterfaceManager::Print("   Class.SubClass.Protocol: %02X.%02X.%02X\n",
+				Interface::Print("   Class.SubClass.Protocol: %02X.%02X.%02X\n",
 					configDescriptor->usb_interface[i].altsetting[j].bInterfaceClass,
 					configDescriptor->usb_interface[i].altsetting[j].bInterfaceSubClass,
 					configDescriptor->usb_interface[i].altsetting[j].bInterfaceProtocol);
@@ -230,9 +269,9 @@ bool BridgeManager::Initialise(void)
 
 				if (verbose)
 				{
-					InterfaceManager::Print("       endpoint[%d].address: %02X\n", k, endpoint->bEndpointAddress);
-					InterfaceManager::Print("           max packet size: %04X\n", endpoint->wMaxPacketSize);
-					InterfaceManager::Print("          polling interval: %02X\n", endpoint->bInterval);
+					Interface::Print("       endpoint[%d].address: %02X\n", k, endpoint->bEndpointAddress);
+					Interface::Print("           max packet size: %04X\n", endpoint->wMaxPacketSize);
+					Interface::Print("          polling interval: %02X\n", endpoint->bInterval);
 				}
 
 				if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN)
@@ -258,11 +297,11 @@ bool BridgeManager::Initialise(void)
 
 	if (result != LIBUSB_SUCCESS)
 	{
-		InterfaceManager::PrintError("Failed to find correct interface configuration\n");
+		Interface::PrintError("Failed to find correct interface configuration\n");
 		return (false);
 	}
 	
-	InterfaceManager::Print("\nClaiming interface...");
+	Interface::Print("\nClaiming interface...");
 	result = libusb_claim_interface(deviceHandle, interfaceIndex);
 
 #ifdef OS_LINUX
@@ -270,9 +309,9 @@ bool BridgeManager::Initialise(void)
 	if (result != LIBUSB_SUCCESS)
 	{
 		detachedDriver = true;
-		InterfaceManager::Print("   Failed. Attempting to detach driver...\n");
+		Interface::Print("   Failed. Attempting to detach driver...\n");
 		libusb_detach_kernel_driver(deviceHandle, interfaceIndex);
-		InterfaceManager::Print("Claiming interface again...");
+		Interface::Print("Claiming interface again...");
 		result = libusb_claim_interface(deviceHandle, interfaceIndex);
 	}
 
@@ -280,28 +319,28 @@ bool BridgeManager::Initialise(void)
 
 	if (result != LIBUSB_SUCCESS)
 	{
-		InterfaceManager::PrintError("   Failed!\n");
+		Interface::PrintError("   Failed!\n");
 		return (false);
 	}
 
-	InterfaceManager::Print("   Success\n");
+	Interface::Print("   Success\n");
 
-	InterfaceManager::Print("Setting up interface...");
+	Interface::Print("Setting up interface...");
 	result = libusb_set_interface_alt_setting(deviceHandle, interfaceIndex, altSettingIndex);
 	if (result != LIBUSB_SUCCESS)
 	{
-		InterfaceManager::PrintError("   Failed!\n");
+		Interface::PrintError("   Failed!\n");
 		return (false);
 	}
 
-	InterfaceManager::Print("   Success\n");
+	Interface::Print("   Success\n");
 
 	return (true);
 }
 
 bool BridgeManager::BeginSession(void) const
 {
-	InterfaceManager::Print("Beginning session...\n");
+	Interface::Print("Beginning session...\n");
 
 	unsigned char *dataBuffer = new unsigned char[7];
 
@@ -309,7 +348,7 @@ bool BridgeManager::BeginSession(void) const
 
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("Failed to initialise usb communication!\n");
+		Interface::PrintError("Failed to initialise usb communication!\n");
 		delete [] dataBuffer;
 		return (false);
 	}
@@ -322,7 +361,7 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_control_transfer(deviceHandle, LIBUSB_REQUEST_TYPE_CLASS, 0x20, 0x0, 0, dataBuffer, 7, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("Failed to initialise usb communication!\n");
+		Interface::PrintError("Failed to initialise usb communication!\n");
 		delete [] dataBuffer;
 		return (false);
 	}
@@ -330,7 +369,7 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_control_transfer(deviceHandle, LIBUSB_REQUEST_TYPE_CLASS, 0x22, 0x3, 0, nullptr, 0, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("Failed to initialise usb communication!\n");
+		Interface::PrintError("Failed to initialise usb communication!\n");
 		delete [] dataBuffer;
 		return (false);
 	}
@@ -338,7 +377,7 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_control_transfer(deviceHandle, LIBUSB_REQUEST_TYPE_CLASS, 0x22, 0x2, 0, nullptr, 0, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("Failed to initialise usb communication!\n");
+		Interface::PrintError("Failed to initialise usb communication!\n");
 		delete [] dataBuffer;
 		return (false);
 	}
@@ -351,7 +390,7 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_control_transfer(deviceHandle, LIBUSB_REQUEST_TYPE_CLASS, 0x20, 0x0, 0, dataBuffer, 7, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("Failed to initialise usb communication!\n");
+		Interface::PrintError("Failed to initialise usb communication!\n");
 		delete [] dataBuffer;
 		return (false);
 	}
@@ -359,12 +398,12 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_control_transfer(deviceHandle, LIBUSB_REQUEST_TYPE_CLASS, 0x22, 0x2, 0, nullptr, 0, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("Failed to initialise usb communication!\n");
+		Interface::PrintError("Failed to initialise usb communication!\n");
 		delete [] dataBuffer;
 		return (false);
 	}
 
-	InterfaceManager::Print("Handshaking with Loke...");
+	Interface::Print("Handshaking with Loke...");
 
 	int dataTransferred;
 
@@ -374,10 +413,10 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_bulk_transfer(deviceHandle, outEndpoint, dataBuffer, 4, &dataTransferred, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("   Failed!\n");
+		Interface::PrintError("   Failed!\n");
 
 		if (verbose)
-			InterfaceManager::PrintError("ERROR: Failed to send data: \"%s\"\n", dataBuffer);
+			Interface::PrintError("ERROR: Failed to send data: \"%s\"\n", dataBuffer);
 
 		delete [] dataBuffer;
 		return (false);
@@ -385,10 +424,10 @@ bool BridgeManager::BeginSession(void) const
 
 	if (dataTransferred != 4)
 	{
-		InterfaceManager::PrintError("   Failed!\n");
+		Interface::PrintError("   Failed!\n");
 
 		if (verbose)
-			InterfaceManager::PrintError("ERROR: Failed to complete sending data: \"%s\"\n", dataBuffer);
+			Interface::PrintError("ERROR: Failed to complete sending data: \"%s\"\n", dataBuffer);
 
 		delete [] dataBuffer;
 		return (false);
@@ -400,32 +439,32 @@ bool BridgeManager::BeginSession(void) const
 	result = libusb_bulk_transfer(deviceHandle, inEndpoint, dataBuffer, 7, &dataTransferred, 1000);
 	if (result < 0)
 	{
-		InterfaceManager::PrintError("   Failed!\n");
+		Interface::PrintError("   Failed!\n");
 
 		if (verbose)
-			InterfaceManager::PrintError("ERROR: Failed to receive response\n");
+			Interface::PrintError("ERROR: Failed to receive response\n");
 		delete [] dataBuffer;
 		return (false);;
 	}
 
 	if (dataTransferred != 4 || memcmp(dataBuffer, "LOKE", 4) != 0)
 	{
-		InterfaceManager::PrintError("   Failed!\n");
+		Interface::PrintError("   Failed!\n");
 
 		if (verbose)
-			InterfaceManager::PrintError("ERROR: Unexpected communication.\nExpected: \"%s\"\nReceived: \"%s\"\n", "LOKE", dataBuffer);
+			Interface::PrintError("ERROR: Unexpected communication.\nExpected: \"%s\"\nReceived: \"%s\"\n", "LOKE", dataBuffer);
 
 		delete [] dataBuffer;
 		return (false);
 	}
 
-	InterfaceManager::Print("   Success\n\n");
+	Interface::Print("   Success\n\n");
 	return (true);
 }
 
-bool BridgeManager::EndSession(void) const
+bool BridgeManager::EndSession(bool reboot) const
 {
-	InterfaceManager::Print("Ending session...\n");
+	Interface::Print("Ending session...\n");
 
 	EndSessionPacket *endSessionPacket = new EndSessionPacket(EndSessionPacket::kRequestEndSession);
 	bool success = SendPacket(endSessionPacket);
@@ -433,7 +472,7 @@ bool BridgeManager::EndSession(void) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to send end session packet!\n");
+		Interface::PrintError("Failed to send end session packet!\n");
 		return (false);
 	}
 
@@ -443,10 +482,35 @@ bool BridgeManager::EndSession(void) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive session end confirmation!\n");
+		Interface::PrintError("Failed to receive session end confirmation!\n");
 		return (false);
 	}
 
+	if (reboot)
+	{
+		Interface::Print("Rebooting device...\n");
+
+		EndSessionPacket *rebootDevicePacket = new EndSessionPacket(EndSessionPacket::kRequestRebootDevice);
+		bool success = SendPacket(rebootDevicePacket);
+		delete rebootDevicePacket;
+
+		if (!success)
+		{
+			Interface::PrintError("Failed to send reboot device packet!\n");
+			return (false);
+		}
+
+		ResponsePacket *rebootDeviceResponse = new ResponsePacket(ResponsePacket::kResponseTypeEndSession);
+		success = ReceivePacket(rebootDeviceResponse);
+		delete rebootDeviceResponse;
+
+		if (!success)
+		{
+			Interface::PrintError("Failed to receive reboot confirmation!\n");
+			return (false);
+		}
+	}
+
 	return (true);
 }
 
@@ -464,13 +528,13 @@ bool BridgeManager::SendPacket(OutboundPacket *packet, int timeout) const
 		int retryDelay = (communicationDelay > 250) ? communicationDelay : 250;
 
 		if (verbose)
-			InterfaceManager::PrintError("Error %i whilst sending packet. ", result);
+			Interface::PrintError("Error %i whilst sending packet. ", result);
 
 		// Retry
 		for (int i = 0; i < 5; i++)
 		{
 			if (verbose)
-				InterfaceManager::PrintError(" Retrying...\n");
+				Interface::PrintError(" Retrying...\n");
 
 			// Wait longer each retry
 			Sleep(retryDelay * (i + 1));
@@ -482,11 +546,11 @@ bool BridgeManager::SendPacket(OutboundPacket *packet, int timeout) const
 				break;
 
 			if (verbose)
-				InterfaceManager::PrintError("Error %i whilst sending packet. ", result);
+				Interface::PrintError("Error %i whilst sending packet. ", result);
 		}
 
 		if (verbose)
-				InterfaceManager::PrintError("\n");
+				Interface::PrintError("\n");
 	}
 
 	if (communicationDelay != 0)
@@ -510,13 +574,13 @@ bool BridgeManager::ReceivePacket(InboundPacket *packet, int timeout) const
 		int retryDelay = (communicationDelay > 250) ? communicationDelay : 250;
 
 		if (verbose)
-			InterfaceManager::PrintError("Error %i whilst receiving packet. ", result);
+			Interface::PrintError("Error %i whilst receiving packet. ", result);
 
 		// Retry
 		for (int i = 0; i < 5; i++)
 		{
 			if (verbose)
-				InterfaceManager::PrintError(" Retrying\n");
+				Interface::PrintError(" Retrying\n");
 
 			// Wait longer each retry
 			Sleep(retryDelay * (i + 1));
@@ -528,7 +592,7 @@ bool BridgeManager::ReceivePacket(InboundPacket *packet, int timeout) const
 				break;
 
 			if (verbose)
-				InterfaceManager::PrintError("Error %i whilst receiving packet. ", result);
+				Interface::PrintError("Error %i whilst receiving packet. ", result);
 
 			if (i >= 3)
 			{
@@ -538,7 +602,7 @@ bool BridgeManager::ReceivePacket(InboundPacket *packet, int timeout) const
 		}
 
 		if (verbose)
-			InterfaceManager::PrintError("\n");
+			Interface::PrintError("\n");
 	}
 
 	if (communicationDelay != 0)
@@ -552,6 +616,24 @@ bool BridgeManager::ReceivePacket(InboundPacket *packet, int timeout) const
 	return (packet->Unpack());
 }
 
+bool BridgeManager::RequestDeviceInfo(unsigned int request, int *result) const
+{
+	DeviceInfoPacket deviceInfoPacket(request);
+	bool success = SendPacket(&deviceInfoPacket);
+
+	if (!success)
+	{
+		Interface::PrintError("Failed to request device info packet!\nFailed Request: %d\n");
+		return (false);
+	}
+
+	DeviceInfoResponse deviceInfoResponse;
+	success = ReceivePacket(&deviceInfoResponse);
+	*result = deviceInfoResponse.GetUnknown();
+
+	return (true);
+}
+
 bool BridgeManager::SendPitFile(FILE *file) const
 {
 	fseek(file, 0, SEEK_END);
@@ -565,7 +647,7 @@ bool BridgeManager::SendPitFile(FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to request sending of PIT file!\n");
+		Interface::PrintError("Failed to request sending of PIT file!\n");
 		return (false);
 	}
 
@@ -575,7 +657,7 @@ bool BridgeManager::SendPitFile(FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to confirm sending of PIT file!\n");
+		Interface::PrintError("Failed to confirm sending of PIT file!\n");
 		return (false);
 	}
 
@@ -586,7 +668,7 @@ bool BridgeManager::SendPitFile(FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to send PIT file part information!\n");
+		Interface::PrintError("Failed to send PIT file part information!\n");
 		return (false);
 	}
 
@@ -596,7 +678,7 @@ bool BridgeManager::SendPitFile(FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to confirm sending of PIT file part information!\n");
+		Interface::PrintError("Failed to confirm sending of PIT file part information!\n");
 		return (false);
 	}
 
@@ -607,7 +689,7 @@ bool BridgeManager::SendPitFile(FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to send file part packet!\n");
+		Interface::PrintError("Failed to send file part packet!\n");
 		return (false);
 	}
 
@@ -617,7 +699,7 @@ bool BridgeManager::SendPitFile(FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive PIT file transfer count!\n");
+		Interface::PrintError("Failed to receive PIT file transfer count!\n");
 		return (false);
 	}
 
@@ -637,7 +719,7 @@ int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to request receival of PIT file!\n");
+		Interface::PrintError("Failed to request receival of PIT file!\n");
 		return (0);
 	}
 
@@ -648,7 +730,7 @@ int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive PIT file size!\n");
+		Interface::PrintError("Failed to receive PIT file size!\n");
 		return (0);
 	}
 
@@ -668,7 +750,7 @@ int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
 
 		if (!success)
 		{
-			InterfaceManager::PrintError("Failed to request PIT file part #%i!\n", i);
+			Interface::PrintError("Failed to request PIT file part #%i!\n", i);
 			delete [] buffer;
 			return (0);
 		}
@@ -678,7 +760,7 @@ int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
 		
 		if (!success)
 		{
-			InterfaceManager::PrintError("Failed to receive PIT file part #%i!\n", i);
+			Interface::PrintError("Failed to receive PIT file part #%i!\n", i);
 			delete receiveFilePartPacket;
 			delete [] buffer;
 			return (0);
@@ -698,7 +780,7 @@ int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to send request to end PIT file transfer!\n");
+		Interface::PrintError("Failed to send request to end PIT file transfer!\n");
 		delete [] buffer;
 		return (0);
 	}
@@ -709,7 +791,7 @@ int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive end PIT file transfer verification!\n");
+		Interface::PrintError("Failed to receive end PIT file transfer verification!\n");
 		delete [] buffer;
 		return (0);
 	}
@@ -722,13 +804,13 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 {
 	if (destination != EndFileTransferPacket::kDestinationModem && destination != EndFileTransferPacket::kDestinationPhone)
 	{
-		InterfaceManager::PrintError("ERROR: Attempted to send file to unknown destination!\n");
+		Interface::PrintError("ERROR: Attempted to send file to unknown destination!\n");
 		return (false);
 	}
 
 	if (destination == EndFileTransferPacket::kDestinationModem && fileIdentifier != -1)
 	{
-		InterfaceManager::PrintError("ERROR: The modem file does not have an identifier!\n");
+		Interface::PrintError("ERROR: The modem file does not have an identifier!\n");
 		return (false);
 	}
 
@@ -738,7 +820,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to initialise transfer!\n");
+		Interface::PrintError("Failed to initialise transfer!\n");
 		return (false);
 	}
 
@@ -752,7 +834,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to confirm transfer initialisation!\n");
+		Interface::PrintError("Failed to confirm transfer initialisation!\n");
 		return (false);
 	}
 
@@ -772,7 +854,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 	long bytesTransferred = 0;
 	int currentPercent;
 	int previousPercent = 0;
-	InterfaceManager::Print("0%%");
+	Interface::Print("0%%");
 
 	for (int sequenceIndex = 0; sequenceIndex < sequenceCount; sequenceIndex++)
 	{
@@ -786,7 +868,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 		if (!success)
 		{
-			InterfaceManager::PrintError("\nFailed to begin file transfer sequence!\n");
+			Interface::PrintError("\nFailed to begin file transfer sequence!\n");
 			return (false);
 		}
 
@@ -796,7 +878,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 		if (!success)
 		{
-			InterfaceManager::PrintError("\nFailed to confirm beginning of file transfer sequence!\n");
+			Interface::PrintError("\nFailed to confirm beginning of file transfer sequence!\n");
 			return (false);
 		}
 
@@ -812,7 +894,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 			if (!success)
 			{
-				InterfaceManager::PrintError("\nFailed to send file part packet!\n");
+				Interface::PrintError("\nFailed to send file part packet!\n");
 				return (false);
 			}
 
@@ -824,7 +906,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 			if (verbose)
 			{
 				const unsigned char *data = sendFilePartResponse->GetData();
-				InterfaceManager::Print("File Part #%i... Response: %X  %X  %X  %X  %X  %X  %X  %X \n", filePartIndex,
+				Interface::Print("File Part #%i... Response: %X  %X  %X  %X  %X  %X  %X  %X \n", filePartIndex,
 					data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
 			}
 
@@ -832,11 +914,11 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 			if (!success)
 			{
-				InterfaceManager::PrintError("\nFailed to receive file part response!\n");
+				Interface::PrintError("\nFailed to receive file part response!\n");
 
 				for (int retry = 0; retry < 4; retry++)
 				{
-					InterfaceManager::PrintError("\nRetrying...");
+					Interface::PrintError("\nRetrying...");
 
 					// Send
 					sendFilePartPacket = new SendFilePartPacket(file);
@@ -845,7 +927,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 					if (!success)
 					{
-						InterfaceManager::PrintError("\nFailed to send file part packet!\n");
+						Interface::PrintError("\nFailed to send file part packet!\n");
 						return (false);
 					}
 
@@ -857,7 +939,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 					if (verbose)
 					{
 						const unsigned char *data = sendFilePartResponse->GetData();
-						InterfaceManager::Print("File Part #%i... Response: %X  %X  %X  %X  %X  %X  %X  %X \n", filePartIndex,
+						Interface::Print("File Part #%i... Response: %X  %X  %X  %X  %X  %X  %X  %X \n", filePartIndex,
 							data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
 					}
 
@@ -865,7 +947,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 					if (receivedPartIndex != filePartIndex)
 					{
-						InterfaceManager::PrintError("\nERROR: Expected file part index: %i Received: %i\n",
+						Interface::PrintError("\nERROR: Expected file part index: %i Received: %i\n",
 							filePartIndex, receivedPartIndex);
 						return (false);
 					}
@@ -880,7 +962,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 			if (receivedPartIndex != filePartIndex)
 			{
-				InterfaceManager::PrintError("\nERROR: Expected file part index: %i Received: %i\n",
+				Interface::PrintError("\nERROR: Expected file part index: %i Received: %i\n",
 					filePartIndex, receivedPartIndex);
 				return (false);
 			}
@@ -896,9 +978,9 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 				if (currentPercent != previousPercent)
 				{
 					if (previousPercent < 10)
-						InterfaceManager::Print("\b\b%i%%", currentPercent);
+						Interface::Print("\b\b%i%%", currentPercent);
 					else
-						InterfaceManager::Print("\b\b\b%i%%", currentPercent);
+						Interface::Print("\b\b\b%i%%", currentPercent);
 				}
 			}
 
@@ -917,7 +999,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 			if (!success)
 			{
-				InterfaceManager::PrintError("\nFailed to end phone file transfer sequence!\n");
+				Interface::PrintError("\nFailed to end phone file transfer sequence!\n");
 				return (false);
 			}
 		}
@@ -931,7 +1013,7 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 			if (!success)
 			{
-				InterfaceManager::PrintError("\nFailed to end modem file transfer sequence!\n");
+				Interface::PrintError("\nFailed to end modem file transfer sequence!\n");
 				return (false);
 			}
 		}
@@ -942,13 +1024,13 @@ bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) co
 
 		if (!success)
 		{
-			InterfaceManager::PrintError("\nFailed to confirm end of file transfer sequence!\n");
+			Interface::PrintError("\nFailed to confirm end of file transfer sequence!\n");
 			return (false);
 		}
 	}
 
 	if (!verbose)
-		InterfaceManager::Print("\n");
+		Interface::Print("\n");
 
 	return (true);
 }
@@ -964,7 +1046,7 @@ bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to request dump!\n");
+		Interface::PrintError("Failed to request dump!\n");
 		return (false);
 	}
 
@@ -975,7 +1057,7 @@ bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive dump size!\n");
+		Interface::PrintError("Failed to receive dump size!\n");
 		return (false);
 	}
 
@@ -994,7 +1076,7 @@ bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
 
 		if (!success)
 		{
-			InterfaceManager::PrintError("Failed to request dump part #%i!\n", i);
+			Interface::PrintError("Failed to request dump part #%i!\n", i);
 			delete [] buffer;
 			return (false);
 		}
@@ -1004,7 +1086,7 @@ bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
 		
 		if (!success)
 		{
-			InterfaceManager::PrintError("Failed to receive dump part #%i!\n", i);
+			Interface::PrintError("Failed to receive dump part #%i!\n", i);
 			continue;
 			delete receiveFilePartPacket;
 			delete [] buffer;
@@ -1040,7 +1122,7 @@ bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to send request to end dump transfer!\n");
+		Interface::PrintError("Failed to send request to end dump transfer!\n");
 		return (false);
 	}
 
@@ -1050,34 +1132,7 @@ bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive end dump transfer verification!\n");
-		return (false);
-	}
-
-	return (true);
-}
-
-bool BridgeManager::RebootDevice(void) const
-{
-	InterfaceManager::Print("Rebooting device...\n");
-
-	EndSessionPacket *rebootDevicePacket = new EndSessionPacket(EndSessionPacket::kRequestRebootDevice);
-	bool success = SendPacket(rebootDevicePacket);
-	delete rebootDevicePacket;
-
-	if (!success)
-	{
-		InterfaceManager::PrintError("Failed to send reboot device packet!\n");
-		return (false);
-	}
-
-	ResponsePacket *rebootDeviceResponse = new ResponsePacket(ResponsePacket::kResponseTypeEndSession);
-	success = ReceivePacket(rebootDeviceResponse);
-	delete rebootDeviceResponse;
-
-	if (!success)
-	{
-		InterfaceManager::PrintError("Failed to receive reboot confirmation!\n");
+		Interface::PrintError("Failed to receive end dump transfer verification!\n");
 		return (false);
 	}
 
diff --git a/heimdall/source/BridgeManager.h b/heimdall/source/BridgeManager.h
index 06e4d61..c28cd9c 100644
--- a/heimdall/source/BridgeManager.h
+++ b/heimdall/source/BridgeManager.h
@@ -97,22 +97,23 @@ namespace Heimdall
 			BridgeManager(bool verbose, int communicationDelay);

 			~BridgeManager();

 

+			bool DetectDevice(void);

 			bool Initialise(void);

 

 			bool BeginSession(void) const;

-			bool EndSession(void) const;

+			bool EndSession(bool reboot) const;

 

 			bool SendPacket(OutboundPacket *packet, int timeout = 3000) const;

 			bool ReceivePacket(InboundPacket *packet, int timeout = 3000) const;

 

+			bool RequestDeviceInfo(unsigned int request, int *result) const;

+

 			bool SendPitFile(FILE *file) const;

 			int ReceivePitFile(unsigned char **pitBuffer) const;

 

 			bool SendFile(FILE *file, int destination, int fileIdentifier = -1) const;

 			bool ReceiveDump(int chipType, int chipId, FILE *file) const;

 

-			bool RebootDevice(void) const;

-

 			bool IsVerbose(void) const

 			{

 				return (verbose);

diff --git a/heimdall/source/Interface.cpp b/heimdall/source/Interface.cpp
new file mode 100644
index 0000000..5f0942d
--- /dev/null
+++ b/heimdall/source/Interface.cpp
@@ -0,0 +1,409 @@
+/* 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 <cstdarg>
+#include <cstdlib>
+#include <stdio.h>
+
+// Heimdall
+#include "Heimdall.h"
+#include "Interface.h"
+
+using namespace std;
+using namespace libpit;
+using namespace Heimdall;
+
+const char *Interface::version = "v1.3.0";
+
+const char *Interface::usage = "Usage: heimdall <action> <arguments> [--verbose] [--no-reboot] [--delay <ms>]\n\
+\n\
+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>] [--normal-boot <filename>] [--system <filename>]\n\
+    [--user-data <filename>] [--fota <filename>] [--hidden <filename>]\n\
+    [--movinand <filename>] [--data <filename>] [--ums <filename>]\n\
+    [--emmc <filename>] [--<partition identifier> <filename>]\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>] [--normal-boot <filename>] [--system <filename>]\n\
+    [--user-data <filename>] [--fota <filename>] [--hidden <filename>]\n\
+    [--movinand <filename>] [--data <filename>] [--ums <filename>]\n\
+    [--emmc <filename>] [--<partition identifier> <filename>]\n\
+description: Flashes firmware files to your phone.\n\
+WARNING: If you're repartitioning it's strongly recommended you specify\n\
+         all files at your disposal, including bootloaders.\n\
+\n\
+action: close-pc-screen\n\
+description: Attempts to get rid off the \"connect phone to PC\" screen.\n\
+\n\
+action: detect\n\
+description: Indicates whether or not a download mode device can be detected.\n\
+\n\
+action: dump\n\
+arguments: --chip-type <NAND | RAM> --chip-id <integer> --output <filename>\n\
+description: Attempts to dump data from the phone corresponding to the\n\
+	specified chip type and chip ID.\n\
+NOTE: Galaxy S phones don't appear to properly support this functionality.\n\
+\n\
+action: print-pit\n\
+description: Dumps the PIT file from the connected device and prints it in\n\
+    a human readable format.\n\
+\n\
+action version\n\
+description: Displays the version number of this binary.\n\
+\n\
+action: help\n\
+description: Displays this dialogue.\n";
+
+const char *Interface::releaseInfo = "Heimdall %s, Copyright (c) 2010-2011, Benjamin Dobell, Glass Echidna\n\
+http://www.glassechidna.com.au\n\n\
+This software is provided free of charge. Copying and redistribution is\nencouraged.\n\n\
+If you appreciate this software and you would like to support future\ndevelopment please consider donating:\n\
+http://www.glassechidna.com.au/donate/\n\n";
+
+// Flash arguments
+string Interface::flashValueArguments[kFlashValueArgCount] = {
+	"-pit", "-factoryfs", "-cache", "-dbdata", "-primary-boot",	"-secondary-boot", "-secondary-boot-backup", "-param", "-kernel", "-recovery", "-efs", "-modem",
+	"-normal-boot", "-system", "-user-data", "-fota", "-hidden", "-movinand", "-data", "-ums", "-emmc", "-%d"
+};
+
+string Interface::flashValueShortArguments[kFlashValueArgCount] = {
+	"pit",  "fs",         "cache",  "db",      "boot",           "sbl",            "sbl2",                   "param",  "z",       "rec",       "efs",  "m",
+	"norm",         "sys",     "udata",      "fota",  "hide",    "nand",      "data",  "ums",  "emmc",  "%d"
+};
+
+string Interface::flashValuelessArguments[kFlashValuelessArgCount] = {
+	"-repartition"
+};
+
+string Interface::flashValuelessShortArguments[kFlashValuelessArgCount] = {
+	"r"
+};
+
+// Dump arguments
+string Interface::dumpValueArguments[kDumpValueArgCount] = {
+	"-chip-type", "-chip-id", "-output"
+};
+
+string Interface::dumpValueShortArguments[kDumpValueArgCount] = {
+	"type",       "id",       "out"
+};
+
+// Common arguments
+string Interface::commonValueArguments[kCommonValueArgCount] = {
+	"-delay"
+};
+
+string Interface::commonValueShortArguments[kCommonValueArgCount] = {
+	"d"
+};
+
+string Interface::commonValuelessArguments[kCommonValuelessArgCount] = {
+	"-verbose", "-no-reboot"
+};
+
+string Interface::commonValuelessShortArguments[kCommonValuelessArgCount] = {
+	"v",        "nobt"
+};
+
+Action Interface::actions[Interface::kActionCount] = {
+	// kActionFlash
+	Action("flash", flashValueArguments, flashValueShortArguments, kFlashValueArgCount,
+		flashValuelessArguments, flashValuelessShortArguments, kFlashValuelessArgCount),
+
+	// kActionClosePcScreen
+	Action("close-pc-screen", nullptr, nullptr, kClosePcScreenValueArgCount,
+		nullptr, nullptr, kClosePcScreenValuelessArgCount),
+
+	// kActionDump
+	Action("dump", dumpValueArguments, dumpValueShortArguments, kDumpValueArgCount,
+		nullptr, nullptr, kDumpValuelessArgCount),
+
+	// kActionPrintPit
+	Action("print-pit", nullptr, nullptr, kPrintPitValueArgCount,
+		nullptr, nullptr, kPrintPitValuelessArgCount),
+
+	// kActionVersion
+	Action("version", nullptr, nullptr, kVersionValueArgCount,
+		nullptr, nullptr, kVersionValuelessArgCount),
+
+	// kActionHelp
+	Action("help", nullptr, nullptr, kHelpValueArgCount,
+		nullptr, nullptr, kHelpValuelessArgCount),
+
+	// kActionDetect
+	Action("detect", nullptr, nullptr, kDetectValueArgCount,
+		nullptr, nullptr, kDetectValuelessArgCount)
+};
+
+bool Interface::GetArguments(int argc, char **argv, map<string, string>& argumentMap, int *actionIndex)
+{
+	if (argc < 2)
+	{
+		Print(usage, version);
+		return (false);
+	}
+
+	const char *actionName = argv[1];
+	*actionIndex = -1;
+
+	for (int i = 0; i < kActionCount; i++)
+	{
+		if (actions[i].name == actionName)
+		{
+			*actionIndex = i;
+			break;
+		}
+	}
+
+	if (*actionIndex < 0)
+	{
+		Print("Unknown action \"%s\"\n\n", actionName);
+		Print(usage, version);
+		return (false);
+	}
+
+	const Action& action = actions[*actionIndex]; 
+
+	for (int argIndex = 2; argIndex < argc; argIndex++)
+	{
+		if (*(argv[argIndex]) != '-')
+		{
+			Print(usage, version);
+			return (false);
+		}
+
+		string argumentName = (char *)(argv[argIndex] + 1);
+
+		// Check if the argument is a valid valueless argument
+		bool valid = false;
+
+		for (unsigned int i = 0; i < action.valuelessArgumentCount; i++)
+		{
+			if (argumentName == action.valuelessArguments[i] || argumentName == action.valuelessShortArguments[i])
+			{
+				argumentName = action.valuelessArguments[i];
+				valid = true;
+				break;
+			}
+		}
+
+		if (!valid)
+		{
+			// Check if it's a common valueless argument
+			for (unsigned int i = 0; i < kCommonValuelessArgCount; i++)
+			{
+				if (argumentName == commonValuelessArguments[i] || argumentName == commonValuelessShortArguments[i])
+				{
+					argumentName = commonValuelessArguments[i];
+					valid = true;
+					break;
+				}
+			}
+		}
+
+		if (valid)
+		{
+			// The argument is valueless
+			argumentMap.insert(pair<string, string>(argumentName, ""));
+			continue;
+		}
+
+		// Check if the argument is a valid value argument
+		for (unsigned int i = 0; i < action.valueArgumentCount; i++)
+		{
+			// Support for --<integer> and -<integer> parameters.
+			if (argumentName.length() > 1 && action.valueArguments[i] == "-%d")
+			{
+				if (atoi(argumentName.substr(1).c_str()) > 0 || argumentName == "-0")
+				{
+					valid = true;
+					break;
+				}
+			}
+			else if (action.valueArguments[i] == "%d")
+			{
+				if (atoi(argumentName.c_str()) > 0 || argumentName == "0")
+				{
+					argumentName = "-" + argumentName;
+					valid = true;
+					break;
+				}
+			}
+
+			if (argumentName == action.valueArguments[i] || argumentName == action.valueShortArguments[i])
+			{
+				argumentName = action.valueArguments[i];
+				valid = true;
+				break;
+			}
+		}
+
+		if (!valid)
+		{
+			// Check if it's a common value argument
+			for (unsigned int i = 0; i < kCommonValueArgCount; i++)
+			{
+				// Support for --<integer> and -<integer> parameters.
+				if (argumentName.length() > 1 && commonValueArguments[i] == "-%d")
+				{
+					if (atoi(argumentName.substr(1).c_str()) > 0 || argumentName == "-0")
+					{
+						valid = true;
+						break;
+					}
+				}
+				else if (commonValueArguments[i] == "%d")
+				{
+					if (atoi(argumentName.c_str()) > 0 || argumentName == "0")
+					{
+						argumentName = "-" + argumentName;
+						valid = true;
+						break;
+					}
+				}
+
+				if (argumentName == commonValueArguments[i] || argumentName == commonValueShortArguments[i])
+				{
+					argumentName = commonValueArguments[i];
+					valid = true;
+					break;
+				}
+			}
+		}
+
+		if (!valid)
+		{
+			PrintError("\"%s\" is not a valid argument\n", argumentName.c_str());
+			return (false);
+		}
+
+		argIndex++;
+
+		if (argIndex >= argc)
+		{
+			PrintError("\"%s\" is missing a value\n", argumentName.c_str());
+			return (false);
+		}
+
+		argumentMap.insert(pair<string, string>(argumentName, argv[argIndex]));
+	}
+
+	return (true);
+}
+
+void Interface::Print(const char *format, ...)
+{
+	va_list args;
+
+	va_start(args, format);
+	vfprintf(stdout, format, args);
+	va_end(args);
+
+	fflush(stdout);	// Make sure output isn't buffered.
+}
+
+void Interface::PrintError(const char *format, ...)
+{
+	va_list args;
+
+	va_start(args, format);
+	vfprintf(stderr, format, args);
+	va_end(args);
+
+	fflush(stderr);	// Make sure output isn't buffered.
+}
+
+void Interface::PrintVersion(void)
+{
+	Print("%s\n", version);
+}
+
+void Interface::PrintUsage(void)
+{
+	Print(usage);
+}
+
+void Interface::PrintReleaseInfo(void)
+{
+	Print(releaseInfo, version);
+}
+
+void Interface::PrintPit(const PitData *pitData)
+{
+	Interface::Print("Entry Count: %d\n", pitData->GetEntryCount());
+
+	Interface::Print("Unknown 1: %d\n", pitData->GetUnknown1());
+	Interface::Print("Unknown 2: %d\n", pitData->GetUnknown2());
+	Interface::Print("Unknown 3: %d\n", pitData->GetUnknown3());
+	Interface::Print("Unknown 4: %d\n", pitData->GetUnknown4());
+	Interface::Print("Unknown 5: %d\n", pitData->GetUnknown5());
+	Interface::Print("Unknown 6: %d\n", pitData->GetUnknown6());
+	Interface::Print("Unknown 7: %d\n", pitData->GetUnknown7());
+	Interface::Print("Unknown 8: %d\n", pitData->GetUnknown8());
+
+	for (unsigned int i = 0; i < pitData->GetEntryCount(); i++)
+	{
+		const PitEntry *entry = pitData->GetEntry(i);
+
+		Interface::Print("\n\n--- Entry #%d ---\n", i);
+		Interface::Print("Unused: %s\n", (entry->GetUnused()) ? "Yes" : "No");
+
+		const char *partitionTypeText = "Unknown";
+
+		if (entry->GetPartitionType() == PitEntry::kPartitionTypeRfs)
+			partitionTypeText = "RFS";
+		else if (entry->GetPartitionType() == PitEntry::kPartitionTypeExt4)
+			partitionTypeText = "EXT4";
+
+		Interface::Print("Partition Type: %d (%s)\n", entry->GetPartitionType(), partitionTypeText);
+
+		Interface::Print("Partition Identifier: %d\n", entry->GetPartitionIdentifier());
+
+		Interface::Print("Partition Flags: %d (", entry->GetPartitionFlags());
+
+		if (entry->GetPartitionFlags() & PitEntry::kPartitionFlagWrite)
+			Interface::Print("R/W");
+		else
+			Interface::Print("R");
+
+		Interface::Print(")\n");
+
+		Interface::Print("Unknown 1: %d\n", entry->GetUnknown1());
+
+		Interface::Print("Partition Block Size: %d\n", entry->GetPartitionBlockSize());
+		Interface::Print("Partition Block Count: %d\n", entry->GetPartitionBlockCount());
+
+		Interface::Print("Unknown 2: %d\n", entry->GetUnknown2());
+		Interface::Print("Unknown 3: %d\n", entry->GetUnknown3());
+
+		Interface::Print("Partition Name: %s\n", entry->GetPartitionName());
+		Interface::Print("Filename: %s\n", entry->GetFilename());
+	}
+
+	Interface::Print("\n");
+}
diff --git a/heimdall/source/Interface.h b/heimdall/source/Interface.h
new file mode 100644
index 0000000..c6bdef3
--- /dev/null
+++ b/heimdall/source/Interface.h
@@ -0,0 +1,255 @@
+/* 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.*/
+
+#ifndef INTERFACE_H
+#define INTERFACE_H
+
+// C/C++ Standard Library
+#include <map>
+#include <string>
+
+// libpit
+#include "libpit.h"
+
+using namespace std;
+using namespace libpit;
+
+namespace Heimdall
+{
+	struct Action
+	{
+		public:
+
+			string name;
+			
+			string *valueArguments;
+			string *valueShortArguments;
+			unsigned int valueArgumentCount;
+
+			string *valuelessArguments;
+			string *valuelessShortArguments;
+			unsigned int valuelessArgumentCount;
+
+			Action(const char *name, string *valueArguments, string *valueShortArguments, unsigned int valueArgumentCount,
+				string *valuelessArguments, string *valuelessShortArguments, unsigned int valuelessArgumentCount)
+			{
+				this->name = name;
+
+				this->valueArguments = valueArguments;
+				this->valueShortArguments = valueShortArguments;
+				this->valueArgumentCount = valueArgumentCount;
+
+				this->valuelessArguments = valuelessArguments;
+				this->valuelessShortArguments = valuelessShortArguments;
+				this->valuelessArgumentCount = valuelessArgumentCount;
+			}
+	};
+
+	class Interface
+	{
+		public:
+
+			// Actions
+			enum
+			{
+				kActionFlash = 0,
+				kActionClosePcScreen,
+				kActionDump,
+				kActionPrintPit,
+				kActionVersion,
+				kActionHelp,
+				kActionDetect,
+				kActionCount
+			};
+
+			// Flash value arguments
+			enum
+			{
+				kFlashValueArgPit,
+				kFlashValueArgFactoryFs,
+				kFlashValueArgCache,
+				kFlashValueArgDatabaseData,
+				kFlashValueArgPrimaryBootloader,
+				kFlashValueArgSecondaryBootloader,
+				kFlashValueArgSecondaryBootloaderBackup,
+				kFlashValueArgParam,
+				kFlashValueArgKernel,
+				kFlashValueArgRecovery,
+				kFlashValueArgEfs,
+				kFlashValueArgModem,
+
+				kFlashValueArgNormalBoot,
+				kFlashValueArgSystem,
+				kFlashValueArgUserData,
+				kFlashValueArgFota,
+				kFlashValueArgHidden,
+				kFlashValueArgMovinand,
+				kFlashValueArgData,
+				kFlashValueArgUms,
+				kFlashValueArgEmmc,
+
+				kFlashValueArgPartitionIndex,
+
+				kFlashValueArgCount
+			};
+
+			// Flash valueless arguments
+			enum
+			{
+				kFlashValuelessArgRepartition = 0,
+
+				kFlashValuelessArgCount
+			};
+
+			// Close PC Screen value arguments
+			enum
+			{
+				kClosePcScreenValueArgCount = 0
+			};
+
+			// Close PC Screen valueless arguments
+			enum
+			{
+				kClosePcScreenValuelessArgCount = 0
+			};
+
+			// Dump value arguments
+			enum
+			{
+				kDumpValueArgChipType = 0,
+				kDumpValueArgChipId,
+				kDumpValueArgOutput,
+
+				kDumpValueArgCount
+			};
+
+			// Dump valueless arguments
+			enum
+			{
+				kDumpValuelessArgCount = 0
+			};
+
+			// Print PIT value arguments
+			enum
+			{
+				kPrintPitValueArgCount = 0
+			};
+
+			// Print PIT valueless arguments
+			enum
+			{
+				kPrintPitValuelessArgCount = 0
+			};
+
+			// Version value arguments
+			enum
+			{
+				kVersionValueArgCount = 0
+			};
+
+			// Version valueless arguments
+			enum
+			{
+				kVersionValuelessArgCount = 0
+			};
+
+			// Help value arguments
+			enum
+			{
+				kHelpValueArgCount = 0
+			};
+
+			// Help valueless arguments
+			enum
+			{
+				kHelpValuelessArgCount = 0
+			};
+
+			// Detect value arguments
+			enum
+			{
+				kDetectValueArgCount = 0
+			};
+
+			// Detect valueless arguments
+			enum
+			{
+				kDetectValuelessArgCount = 0
+			};
+
+			// Common value arguments
+			enum
+			{
+				kCommonValueArgDelay = 0,
+
+				kCommonValueArgCount
+			};
+
+			// Comon valueless arguments
+			enum
+			{
+				kCommonValuelessArgVerbose = 0,
+				kCommonValuelessArgNoReboot,
+
+				kCommonValuelessArgCount
+			};
+
+		private:
+		
+			static const char *version;
+			static const char *usage;
+			static const char *releaseInfo;			
+
+			// Flash arguments
+			static string flashValueArguments[kFlashValueArgCount];
+			static string flashValueShortArguments[kFlashValueArgCount];
+
+			static string flashValuelessArguments[kFlashValuelessArgCount];
+			static string flashValuelessShortArguments[kFlashValuelessArgCount];
+
+			// Dump arguments
+			static string dumpValueArguments[kDumpValueArgCount];
+			static string dumpValueShortArguments[kDumpValueArgCount];
+
+		public:
+
+			// Common arguments
+			static string commonValueArguments[kCommonValueArgCount];
+			static string commonValueShortArguments[kCommonValueArgCount];
+
+			static string commonValuelessArguments[kCommonValuelessArgCount];
+			static string commonValuelessShortArguments[kCommonValuelessArgCount];
+
+			static Action actions[kActionCount];
+
+			static bool GetArguments(int argc, char **argv, map<string, string>& argumentMap, int *actionIndex);
+
+			static void Print(const char *format, ...);
+			static void PrintError(const char *format, ...);
+
+			static void PrintVersion(void);
+			static void PrintUsage(void);
+			static void PrintReleaseInfo(void);
+
+			static void PrintPit(const PitData *pitData);
+	};
+}
+
+#endif
diff --git a/heimdall/source/InterfaceManager.cpp b/heimdall/source/InterfaceManager.cpp
deleted file mode 100644
index 26ef028..0000000
--- a/heimdall/source/InterfaceManager.cpp
+++ /dev/null
@@ -1,325 +0,0 @@
-/* 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 <cstdarg>

-#include <cstdlib>

-#include <stdio.h>

-

-// Heimdall

-#include "Heimdall.h"

-#include "InterfaceManager.h"

-

-using namespace std;

-using namespace Heimdall;

-

-string InterfaceManager::actionNames[kActionCount] = { "flash", "close-pc-screen", "dump", "print-pit", "help" };

-

-string InterfaceManager::flashArgumentNames[kFlashArgCount * 2] = {

-	// --- Long Names ---

-	"-repartition",

-

-	"-pit", "-factoryfs", "-cache", "-dbdata", "-primary-boot",	"-secondary-boot", "-secondary-boot-backup", "-param", "-kernel", "-recovery", "-efs", "-modem",

-	"-normal-boot", "-system", "-user-data", "-fota", "-hidden", "-movinand", "-data", "-ums", "-emmc", "-%d",

-

-	// --- Short Names ---

-	"r",

-

-	"pit",  "fs",         "cache",  "db",      "boot",           "sbl",            "sbl2",                   "param",  "z",       "rec",       "efs",  "m",

-	"norm",         "sys",     "udata",      "fota",  "hide",    "nand",      "data",  "ums",  "emmc",  "%d"

-};

-

-string InterfaceManager::dumpArgumentNames[kDumpArgCount * 2] = {

-	// --- Long Names ---

-	"-chip-type", "-chip-id", "-output",

-

-	// --- Short Names ---

-	"type",       "id",       "out"

-};

-

-string InterfaceManager::commonArgumentNames[kCommonArgCount * 2] = {

-	// --- Long Names ---

-	"-verbose", "-no-reboot",

-

-	"-delay",

-

-	// --- Short Names ---

-	"v",        "nobt",

-

-	"d"

-};

-

-// argumentNames[kActionCount][] stores common arguments. 

-string *InterfaceManager::actionArgumentNames[kActionCount + 1] = {

-	// kActionFlash

-	flashArgumentNames,

-

-	// kActionClosePcScreen

-	nullptr,

-

-	// kActionDump

-	dumpArgumentNames,

-

-	// kActionPrintPit

-	nullptr,

-

-	// kActionHelp

-	nullptr,

-

-	// Common (kActionCount)

-	commonArgumentNames

-};

-

-int InterfaceManager::actionArgumentCounts[kActionCount + 1] = {

-	kFlashArgCount, 0, kDumpArgCount, 0, 0, kCommonArgCount

-};

-

-int InterfaceManager::actionValuelessArgumentCounts[kActionCount + 1] = {

-	kFlashArgPit, 0, kDumpArgChipType, 0, 0, kCommonArgDelay

-};

-

-const char *InterfaceManager::usage = "\nHeimdall v1.2.0, Copyright (c) 2010-2011, Benjamin Dobell, Glass Echidna\n\n\

-Usage: heimdall <action> <arguments> [--verbose] [--no-reboot] [--delay <ms>]\n\

-\n\

-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>] [--normal-boot <filename>] [--system <filename>]\n\

-	[--user-data <filename>] [--fota <filename>] [--hidden <filename>]\n\

-	[--movinand <filename>] [--data <filename>] [--ums <filename>]\n\

-	[--emmc <filename>] [--<partition identifier> <filename>]\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>] [--normal-boot <filename>] [--system <filename>]\n\

-	[--user-data <filename>] [--fota <filename>] [--hidden <filename>]\n\

-	[--movinand <filename>] [--data <filename>] [--ums <filename>]\n\

-	[--emmc <filename>] [--<partition identifier> <filename>]\n\

-description: Flashes firmware files to your phone.\n\

-WARNING: If you're repartitioning it's strongly recommended you specify\n\

-         all files at your disposal, including bootloaders.\n\

-\n\

-action: close-pc-screen\n\

-description: Attempts to get rid off the \"connect phone to PC\" screen.\n\

-\n\

-action: dump\n\

-arguments: --chip-type <NAND | RAM> --chip-id <integer> --output <filename>\n\

-description: Attempts to dump data from the phone corresponding to the\n\

-	specified chip type and chip ID.\n\

-NOTE: Galaxy S phones don't appear to properly support this functionality.\n\

-\n\

-action: print-pit\n\

-description: Dumps the PIT file from the connected device and prints it in\n\

-    a human readable format.\n\

-\n\

-action: help\n\

-description: Display this dialogue.\n";

-

-bool InterfaceManager::GetArguments(int argc, char **argv, map<string, string>& argumentMap, int *actionIndex)

-{

-	if (argc < 2)

-	{

-		Print(usage);

-		return (false);

-	}

-

-	const char *actionName = argv[1];

-	*actionIndex = -1;

-

-	for (int i = 0; i < kActionCount; i++)

-	{

-		if (actionNames[i] == actionName)

-		{

-			*actionIndex = i;

-			break;

-		}

-	}

-

-	if (*actionIndex < 0)

-	{

-		Print("Unknown action \"%s\"\n\n", actionName);

-		Print(usage);

-		return (false);

-	}

-

-	int actionArgumentCount = actionArgumentCounts[*actionIndex];

-	int commonArgumentCount = actionArgumentCounts[kActionCount];

-

-	int actionValuelessArgumentCount = actionValuelessArgumentCounts[*actionIndex];

-	int commonValuelessArgumentCount = actionValuelessArgumentCounts[kActionCount];

-

-	string *argumentNames = actionArgumentNames[*actionIndex];

-	string *commonArgumentNames = actionArgumentNames[kActionCount];

-

-	for (int argIndex = 2; argIndex < argc; argIndex++)

-	{

-		if (*(argv[argIndex]) != '-')

-		{

-			Print(usage);

-			return (false);

-		}

-

-		string argumentName = (char *)(argv[argIndex] + 1);

-

-		// Check if the argument is a valid valueless argument

-		bool valid = false;

-

-		for (int i = 0; i < actionValuelessArgumentCount; i++)

-		{

-			if (argumentName == argumentNames[i] || argumentName == argumentNames[actionArgumentCount + i])

-			{

-				argumentName = argumentNames[i];

-				valid = true;

-				break;

-			}

-		}

-

-		if (!valid)

-		{

-			// Check if it's a common valueless argument

-			for (int i = 0; i < commonValuelessArgumentCount; i++)

-			{

-				if (argumentName == commonArgumentNames[i] || argumentName == commonArgumentNames[commonArgumentCount + i])

-				{

-					argumentName = commonArgumentNames[i];

-					valid = true;

-					break;

-				}

-			}

-		}

-

-		if (valid)

-		{

-			// The argument is valueless

-			argumentMap.insert(pair<string, string>(argumentName, ""));

-			continue;

-		}

-

-		if (argumentNames != nullptr)

-		{

-			// Check if the argument is a valid regular argument

-			for (int i = actionValuelessArgumentCount; i < actionArgumentCount; i++)

-			{

-				// Support for --<integer> and -<integer> parameters.

-				if (argumentName.length() > 1 && argumentNames[i].compare("-%d") == 0)

-				{

-					if (atoi(argumentName.substr(1).c_str()) > 0 || argumentName.compare("-0") == 0)

-					{

-						valid = true;

-						break;

-					}

-				}

-				else if (argumentNames[i].compare("%d") == 0)

-				{

-					if (atoi(argumentName.c_str()) > 0 || argumentName.compare("0") == 0)

-					{

-						argumentName = "-" + argumentName;

-						valid = true;

-						break;

-					}

-				}

-

-				if (argumentName == argumentNames[i] || argumentName == argumentNames[actionArgumentCount + i])

-				{

-					argumentName = argumentNames[i];

-					valid = true;

-					break;

-				}

-			}

-		}

-

-		if (!valid)

-		{

-			// Check if it's a common regular argument

-			for (int i = commonValuelessArgumentCount; i < commonArgumentCount; i++)

-			{

-				// Support for --<integer> and -<integer> parameters.

-				if (argumentName.length() > 1 && commonArgumentNames[i].compare("-%d"))

-				{

-					if (atoi(argumentName.substr(1).c_str()) > 0 || argumentName.compare("-0") == 0)

-					{

-						valid = true;

-						break;

-					}

-				}

-				else if (commonArgumentNames[i].compare("%d"))

-				{

-					if (atoi(argumentName.c_str()) > 0 || argumentName.compare("0") == 0)

-					{

-						argumentName = "-" + argumentName;

-						valid = true;

-						break;

-					}

-				}

-

-				if (argumentName == commonArgumentNames[i] || argumentName == commonArgumentNames[commonArgumentCount + i])

-				{

-					argumentName = commonArgumentNames[i];

-					valid = true;

-					break;

-				}

-			}

-		}

-

-		if (!valid)

-		{

-			PrintError("\"%s\" is not a valid argument\n", argumentName.c_str());

-			return (false);

-		}

-

-		argIndex++;

-

-		if (argIndex >= argc)

-		{

-			PrintError("\"%s\" is missing a value\n", argumentName.c_str());

-			return (false);

-		}

-

-		argumentMap.insert(pair<string, string>(argumentName, argv[argIndex]));

-	}

-

-	return (true);

-}

-

-void InterfaceManager::Print(const char *format, ...)

-{

-	va_list args;

-

-	va_start(args, format);

-	vfprintf(stdout, format, args);

-	va_end(args);

-

-	fflush(stdout);	// Make sure output isn't buffered.

-}

-

-void InterfaceManager::PrintError(const char *format, ...)

-{

-	va_list args;

-

-	va_start(args, format);

-	vfprintf(stderr, format, args);

-	va_end(args);

-

-	fflush(stderr);	// Make sure output isn't buffered.

-}

diff --git a/heimdall/source/InterfaceManager.h b/heimdall/source/InterfaceManager.h
deleted file mode 100644
index 1f5ba94..0000000
--- a/heimdall/source/InterfaceManager.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/* 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.*/
-
-#ifndef INTERFACEMANAGER_H
-#define INTERFACEMANAGER_H
-
-// C/C++ Standard Library
-#include <map>
-#include <string>
-
-using namespace std;
-
-namespace Heimdall
-{
-	class InterfaceManager
-	{
-		public:
-
-			enum
-			{
-				kActionFlash = 0,
-				kActionClosePcScreen,
-				kActionDump,
-				kActionPrintPit,
-				kActionHelp,
-				kActionCount
-			};
-
-			enum
-			{
-				// Valueless arguments
-				kFlashArgRepartition = 0,
-
-				// Regular arguments
-				kFlashArgPit,
-				kFlashArgFactoryFs,
-				kFlashArgCache,
-				kFlashArgDatabaseData,
-				kFlashArgPrimaryBootloader,
-				kFlashArgSecondaryBootloader,
-				kFlashArgSecondaryBootloaderBackup,
-				kFlashArgParam,
-				kFlashArgKernel,
-				kFlashArgRecovery,
-				kFlashArgEfs,
-				kFlashArgModem,
-
-				kFlashArgNormalBoot,
-				kFlashArgSystem,
-				kFlashArgUserData,
-				kFlashArgFota,
-				kFlashArgHidden,
-				kFlashArgMovinand,
-				kFlashArgData,
-				kFlashArgUms,
-				kFlashArgEmmc,
-
-				kFlashArgPartitionIndex,
-
-				kFlashArgCount
-			};
-
-			enum
-			{
-				// Regular arguments
-				kDumpArgChipType = 0,
-				kDumpArgChipId,
-				kDumpArgOutput,
-
-				kDumpArgCount
-			};
-
-			enum
-			{
-				// Valueless arguments
-				kCommonArgVerbose = 0,
-				kCommonArgNoReboot,
-
-				// Regular arguments
-				kCommonArgDelay,
-
-				kCommonArgCount
-			};
-
-			static string actionNames[kActionCount];
-
-			static string flashArgumentNames[kFlashArgCount * 2];
-			static string dumpArgumentNames[kDumpArgCount * 2];
-			static string commonArgumentNames[kCommonArgCount * 2];
-
-			// argumentNames[kActionCount][] defines common arguments. 
-			static string *actionArgumentNames[kActionCount + 1];
-
-			static int actionArgumentCounts[kActionCount + 1];
-			static int actionValuelessArgumentCounts[kActionCount + 1];
-
-			static const char *usage;
-
-			static bool GetArguments(int argc, char **argv, map<string, string>& argumentMap, int *actionIndex);
-
-			static void Print(const char *format, ...);
-			static void PrintError(const char *format, ...);
-	};
-}
-
-#endif
diff --git a/heimdall/source/OutboundPacket.h b/heimdall/source/OutboundPacket.h
index dbe3f8a..8f8e6c6 100644
--- a/heimdall/source/OutboundPacket.h
+++ b/heimdall/source/OutboundPacket.h
@@ -21,7 +21,7 @@
 #ifndef OUTBOUNDPACKET_H

 #define OUTBOUNDPACKET_H

 

-// Heimdall include

+// Heimdall

 #include "Packet.h"

 

 namespace Heimdall

diff --git a/heimdall/source/main.cpp b/heimdall/source/main.cpp
index 84260f0..64cc553 100644
--- a/heimdall/source/main.cpp
+++ b/heimdall/source/main.cpp
@@ -24,14 +24,16 @@
 #include <stdio.h>
 #include <string>
 
+// libpit
+#include "libpit.h"
+
 // Heimdall
 #include "BridgeManager.h"
 #include "DeviceInfoPacket.h"
 #include "DeviceInfoResponse.h"
 #include "EndModemFileTransferPacket.h"
 #include "EndPhoneFileTransferPacket.h"
-#include "InterfaceManager.h"
-#include "PitData.h"
+#include "Interface.h"
 
 using namespace std;
 using namespace Heimdall;
@@ -110,6 +112,26 @@ void initialiseKnownPartitionNames(void)
 	knownPartitionNames[kKnownPartitionEmmc].push_back("GANG");
 }
 
+bool isKnownPartition(const char *partitionName, unsigned int knownPartitionIndex)
+{
+	for (unsigned int i = 0; i < knownPartitionNames[knownPartitionIndex].size(); i++)
+	{
+		if (strcmp(partitionName, knownPartitionNames[knownPartitionIndex][i]) == 0)
+			return (true);
+	}
+
+	return (false);
+}
+
+bool isKnownBootPartition(const char *partitionName)
+{
+	return (isKnownPartition(partitionName, kKnownPartitionPrimaryBootloader) ||
+		isKnownPartition(partitionName, kKnownPartitionSecondaryBootloader) ||
+		isKnownPartition(partitionName, kKnownPartitionSecondaryBootloaderBackup) ||
+		isKnownPartition(partitionName, kKnownPartitionParam) ||
+		isKnownPartition(partitionName, kKnownPartitionNormalBoot));
+}
+
 bool openFiles(const map<string, string>& argumentMap, map<string, FILE *>& argumentFileMap)
 {
 	map<string, string>::const_iterator it = argumentMap.begin();
@@ -130,7 +152,7 @@ bool openFiles(const map<string, string>& argumentMap, map<string, FILE *>& argu
 			// The argument wasn't a partition index, check if it's a known partition name.
 			for (int knownPartition = 0; knownPartition < kKnownPartitionCount; knownPartition++)
 			{
-				if (it->first.compare(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit + knownPartition]) == 0)
+				if (it->first == Interface::actions[Interface::kActionFlash].valueArguments[knownPartition])
 				{
 					isFileArgument = true;
 					break;
@@ -147,7 +169,7 @@ bool openFiles(const map<string, string>& argumentMap, map<string, FILE *>& argu
 
 		if (!argumentFilePair.second)
 		{
-			InterfaceManager::PrintError("Failed to open file \"%s\"\n", it->second.c_str());
+			Interface::PrintError("Failed to open file \"%s\"\n", it->second.c_str());
 			return (false);
 		}
 
@@ -179,7 +201,7 @@ bool mapFilesToPartitions(const map<string, FILE *>& argumentFileMap, const PitD
 
 			for (knownPartition = 0; knownPartition < kKnownPartitionCount; knownPartition++)
 			{
-				if (it->first.compare(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit + knownPartition]) == 0)
+				if (it->first == Interface::actions[Interface::kActionFlash].valueArguments[knownPartition])
 					break;
 			}
 
@@ -195,7 +217,7 @@ bool mapFilesToPartitions(const map<string, FILE *>& argumentFileMap, const PitD
 
 		if (!pitEntry)
 		{
-			InterfaceManager::PrintError("Partition corresponding to %s argument could not be located\n", it->first.c_str());
+			Interface::PrintError("Partition corresponding to %s argument could not be located\n", it->first.c_str());
 			return (false);
 		}
 
@@ -216,18 +238,18 @@ void closeFiles(map<string, FILE *> argumentfileMap)
 
 int downloadPitFile(BridgeManager *bridgeManager, unsigned char **pitBuffer)
 {
-	InterfaceManager::Print("Downloading device's PIT file...\n");
+	Interface::Print("Downloading device's PIT file...\n");
 
 	int devicePitFileSize = bridgeManager->ReceivePitFile(pitBuffer);
 
 	if (!*pitBuffer)
 	{
-		InterfaceManager::PrintError("Failed to download PIT file!\n");
+		Interface::PrintError("Failed to download PIT file!\n");
 
 		return (-1);
 	}
 
-	InterfaceManager::Print("PIT file download sucessful\n\n");
+	Interface::Print("PIT file download sucessful\n\n");
 	return devicePitFileSize;
 }
 
@@ -247,16 +269,16 @@ bool flashFile(BridgeManager *bridgeManager, unsigned int partitionIndex, const
 
 	if (isPit)
 	{
-		InterfaceManager::Print("Uploading %s\n", partitionName);
+		Interface::Print("Uploading %s\n", partitionName);
 
 		if (bridgeManager->SendPitFile(file))
 		{
-			InterfaceManager::Print("%s upload successful\n", partitionName);
+			Interface::Print("%s upload successful\n", partitionName);
 			return (true);
 		}
 		else
 		{
-			InterfaceManager::PrintError("%s upload failed!\n", partitionName);
+			Interface::PrintError("%s upload failed!\n", partitionName);
 			return (false);
 		}
 	}
@@ -276,34 +298,34 @@ bool flashFile(BridgeManager *bridgeManager, unsigned int partitionIndex, const
 
 		if (isModem)
 		{			
-			InterfaceManager::Print("Uploading %s\n", partitionName);
+			Interface::Print("Uploading %s\n", partitionName);
 
 			//if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone,    // <-- Kies method. WARNING: Doesn't work on Galaxy Tab!
 			//	EndPhoneFileTransferPacket::kFileModem))
 			if (bridgeManager->SendFile(file, EndModemFileTransferPacket::kDestinationModem))     // <-- Odin method
 			{
-				InterfaceManager::Print("%s upload successful\n", partitionName);
+				Interface::Print("%s upload successful\n", partitionName);
 				return (true);
 			}
 			else
 			{
-				InterfaceManager::PrintError("%s upload failed!\n", partitionName);
+				Interface::PrintError("%s upload failed!\n", partitionName);
 				return (false);
 			}
 		}
 		else
 		{
 			// We're uploading to a phone partition
-			InterfaceManager::Print("Uploading %s\n", partitionName);
+			Interface::Print("Uploading %s\n", partitionName);
 
 			if (bridgeManager->SendFile(file, EndPhoneFileTransferPacket::kDestinationPhone, partitionIndex))
 			{
-				InterfaceManager::Print("%s upload successful\n", partitionName);
+				Interface::Print("%s upload successful\n", partitionName);
 				return (true);
 			}
 			else
 			{
-				InterfaceManager::PrintError("%s upload failed!\n", partitionName);
+				Interface::PrintError("%s upload failed!\n", partitionName);
 				return (false);
 			}
 		}
@@ -318,63 +340,31 @@ bool attemptFlash(BridgeManager *bridgeManager, map<string, FILE *> argumentFile
 	
 	// ---------- 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");
+	int deviceInfoResult;
+	
+	if (!bridgeManager->RequestDeviceInfo(DeviceInfoPacket::kUnknown1, &deviceInfoResult))
 		return (false);
-	}
 
 	// 131072 for Galaxy S II, 0 for other devices.
-	if (unknown != 0 && unknown != 131072)
+	if (deviceInfoResult != 0 && deviceInfoResult != 131072)
 	{
-		InterfaceManager::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%i\n", unknown);
+		Interface::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%i\n", deviceInfoResult);
 		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");
+	if (!bridgeManager->RequestDeviceInfo(DeviceInfoPacket::kUnknown2, &deviceInfoResult))
 		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, 3 on the Galaxy Tab, 190 for SHW-M110S.
-	if (unknown != 180 && unknown != 0 && unknown != 3 && unknown != 190)
+	if (deviceInfoResult != 180 && deviceInfoResult != 0 && deviceInfoResult != 3 && deviceInfoResult != 190)
 	{
-		InterfaceManager::PrintError("Unexpected device info response!\nExpected: 180, 0 or 3\nReceived:%i\n", unknown);
+		Interface::PrintError("Unexpected device info response!\nExpected: 180, 0 or 3\nReceived:%i\n", deviceInfoResult);
 		return (false);
 	}
-	// --------------------------------------------------------------
+
+	// ------------- SEND TOTAL BYTES TO BE TRANSFERRED -------------
 
 	int totalBytes = 0;
 	for (map<string, FILE *>::const_iterator it = argumentFileMap.begin(); it != argumentFileMap.end(); it++)
@@ -384,30 +374,30 @@ bool attemptFlash(BridgeManager *bridgeManager, map<string, FILE *> argumentFile
 		rewind(it->second);
 	}
 	
-	deviceInfoPacket = new DeviceInfoPacket(DeviceInfoPacket::kTotalBytes, totalBytes);
+	DeviceInfoPacket *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");
+		Interface::PrintError("Failed to send total bytes device info packet!\n");
 		return (false);
 	}
 
-	deviceInfoResponse = new DeviceInfoResponse();
+	DeviceInfoResponse *deviceInfoResponse = new DeviceInfoResponse();
 	success = bridgeManager->ReceivePacket(deviceInfoResponse);
-	unknown = deviceInfoResponse->GetUnknown();
+	deviceInfoResult = deviceInfoResponse->GetUnknown();
 	delete deviceInfoResponse;
 
 	if (!success)
 	{
-		InterfaceManager::PrintError("Failed to receive device info response!\n");
+		Interface::PrintError("Failed to receive device info response!\n");
 		return (false);
 	}
 
-	if (unknown != 0)
+	if (deviceInfoResult != 0)
 	{
-		InterfaceManager::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%i\n", unknown);
+		Interface::PrintError("Unexpected device info response!\nExpected: 0\nReceived:%i\n", deviceInfoResult);
 		return (false);
 	}
 
@@ -419,13 +409,12 @@ bool attemptFlash(BridgeManager *bridgeManager, map<string, FILE *> argumentFile
 	if (repartition)
 	{
 		// If we're repartitioning then we need to unpack the information from the specified PIT file.
-
-		map<string, FILE *>::iterator it = argumentFileMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit]);
+		map<string, FILE *>::iterator it = argumentFileMap.find(Interface::actions[Interface::kActionFlash].valueArguments[Interface::kFlashValueArgPit]);
 
 		// This shouldn't ever happen due to early checks, but we'll check again just in case...
 		if (it == argumentFileMap.end())
 		{
-			InterfaceManager::PrintError("Attempt was made to repartition without specifying a PIT file!\n");
+			Interface::PrintError("Attempt was made to repartition without specifying a PIT file!\n");
 			return (false);
 		}
 
@@ -451,7 +440,6 @@ bool attemptFlash(BridgeManager *bridgeManager, map<string, FILE *> argumentFile
 	else
 	{
 		// If we're not repartitioning then we need to retrieve the device's PIT file and unpack it.
-
 		unsigned char *pitFileBuffer;
 		downloadPitFile(bridgeManager, &pitFileBuffer);
 
@@ -463,9 +451,13 @@ bool attemptFlash(BridgeManager *bridgeManager, map<string, FILE *> argumentFile
 
 	map<unsigned int, PartitionNameFilePair> partitionFileMap;
 
-	// Map the files being flashed to partitions stored in PIT file.
-	mapFilesToPartitions(argumentFileMap, pitData, partitionFileMap);
-	
+	// Map the files being flashed to partitions stored in the PIT file.
+	if (!mapFilesToPartitions(argumentFileMap, pitData, partitionFileMap))
+	{
+		delete pitData;
+		return (false);
+	}
+
 	delete pitData;
 
 	// If we're repartitioning then we need to flash the PIT file first.
@@ -477,14 +469,26 @@ bool attemptFlash(BridgeManager *bridgeManager, map<string, FILE *> argumentFile
 			{
 				if (!flashFile(bridgeManager, it->first, it->second.partitionName.c_str(), it->second.file))
 					return (false);
+
+				break;
 			}
 		}
 	}
 
-	// Flash all other files
+	// Flash partitions not involved in the boot process second.
 	for (map<unsigned int, PartitionNameFilePair>::iterator it = partitionFileMap.begin(); it != partitionFileMap.end(); it++)
 	{
-		if (it->second.file != localPitFile)
+		if (!isKnownPartition(it->second.partitionName.c_str(), kKnownPartitionPit) && !isKnownBootPartition(it->second.partitionName.c_str()))
+		{
+			if (!flashFile(bridgeManager, it->first, it->second.partitionName.c_str(), it->second.file))
+				return (false);
+		}
+	}
+
+	// Flash boot partitions last.
+	for (map<unsigned int, PartitionNameFilePair>::iterator it = partitionFileMap.begin(); it != partitionFileMap.end(); it++)
+	{
+		if (isKnownBootPartition(it->second.partitionName.c_str()))
 		{
 			if (!flashFile(bridgeManager, it->first, it->second.partitionName.c_str(), it->second.file))
 				return (false);
@@ -499,7 +503,7 @@ int main(int argc, char **argv)
 	map<string, string> argumentMap;
 	int actionIndex;
 
-	if (!InterfaceManager::GetArguments(argc, argv, argumentMap, &actionIndex))
+	if (!Interface::GetArguments(argc, argv, argumentMap, &actionIndex))
 	{
 		Sleep(250);
 		return (0);
@@ -507,83 +511,95 @@ int main(int argc, char **argv)
 
 	initialiseKnownPartitionNames();
 
-	if (actionIndex == InterfaceManager::kActionHelp)
-	{
-		InterfaceManager::Print(InterfaceManager::usage);
-		return (0);
-	}
-	else if (actionIndex == InterfaceManager::kActionFlash)
+	switch (actionIndex)
 	{
-		if (argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgRepartition]) != argumentMap.end()
-			&& argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit]) == argumentMap.end())
-		{
-			InterfaceManager::Print("If you wish to repartition then a PIT file must be specified.\n");
-			return (0);
-		}
+		case Interface::kActionFlash:
+			if (argumentMap.find(Interface::actions[Interface::kActionFlash].valuelessArguments[Interface::kFlashValuelessArgRepartition]) != argumentMap.end()
+				&& argumentMap.find(Interface::actions[Interface::kActionFlash].valueArguments[Interface::kFlashValueArgPit]) == argumentMap.end())
+			{
+				Interface::Print("If you wish to repartition then a PIT file must be specified.\n");
+				return (0);
+			}
 
-		if (argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgPit]) != argumentMap.end()
-			&& argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgRepartition]) == argumentMap.end())
-		{
-			InterfaceManager::Print("A PIT file should only be used when repartitioning.\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(Interface::actions[Interface::kActionFlash].valueArguments[Interface::kFlashValueArgPit]) != argumentMap.end()
+				&& argumentMap.find(Interface::actions[Interface::kActionFlash].valuelessArguments[Interface::kFlashValuelessArgRepartition]) == argumentMap.end())
+			{
+				Interface::Print("A PIT file should only be used when repartitioning.\n");
+				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);
-		}
+			break;
 
-		string chipType = argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipType])->second;
-		if (!(chipType == "RAM" || chipType == "ram" || chipType == "NAND" || chipType == "nand"))
+		case Interface::kActionDump:
 		{
-			InterfaceManager::Print("Unknown chip type: %s.\n\n", chipType.c_str());
-			InterfaceManager::Print(InterfaceManager::usage);
-			return (0);
+			if (argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgOutput]) == argumentMap.end())
+			{
+				Interface::Print("Output file not specified.\n\n");
+				Interface::PrintUsage();
+				return (0);
+			}
+
+			if (argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgChipType]) == argumentMap.end())
+			{
+				Interface::Print("You must specify a chip type.\n\n");
+				Interface::PrintUsage();
+				return (0);
+			}
+
+			string chipType = argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgChipType])->second;
+			if (!(chipType == "RAM" || chipType == "ram" || chipType == "NAND" || chipType == "nand"))
+			{
+				Interface::Print("Unknown chip type: %s.\n\n", chipType.c_str());
+				Interface::PrintUsage();
+				return (0);
+			}
+
+			if (argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgChipId]) == argumentMap.end())
+			{
+				Interface::Print("You must specify a Chip ID.\n\n");
+				Interface::PrintUsage();
+				return (0);
+			}
+
+			int chipId = atoi(argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgChipId])->second.c_str());
+			if (chipId < 0)
+			{
+				Interface::Print("Chip ID must be a non-negative integer.\n");
+				return (0);
+			}
+
+			break;
 		}
 
-		if (argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipId]) == argumentMap.end())
-		{
-			InterfaceManager::Print("You must specify a Chip ID.\n\n");
-			InterfaceManager::Print(InterfaceManager::usage);
+		case Interface::kActionVersion:
+			Interface::PrintVersion();
 			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");
+		case Interface::kActionHelp:
+			Interface::PrintUsage();
 			return (0);
-		}
 	}
 
-	InterfaceManager::Print("\nHeimdall v1.2.0, Copyright (c) 2010-2011, 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();
-	bool noReboot = argumentMap.find(InterfaceManager::commonArgumentNames[InterfaceManager::kCommonArgNoReboot]) != argumentMap.end();
+	bool verbose = argumentMap.find(Interface::commonValuelessArguments[Interface::kCommonValuelessArgVerbose]) != argumentMap.end();
+	bool reboot = argumentMap.find(Interface::commonValuelessArguments[Interface::kCommonValuelessArgNoReboot]) == 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());
+	if (argumentMap.find(Interface::commonValueArguments[Interface::kCommonValueArgDelay]) != argumentMap.end())
+		communicationDelay = atoi(argumentMap.find(Interface::commonValueArguments[Interface::kCommonValueArgDelay])->second.c_str());
 
 	BridgeManager *bridgeManager = new BridgeManager(verbose, communicationDelay);
 
+	if (actionIndex == Interface::kActionDetect)
+	{
+		bridgeManager->DetectDevice();
+
+		delete bridgeManager;
+		return (0);
+	}
+
+	Interface::PrintReleaseInfo();
+	Sleep(1000);
+
 	if (!bridgeManager->Initialise())
 	{
 		delete bridgeManager;
@@ -594,7 +610,7 @@ int main(int argc, char **argv)
 
 	switch (actionIndex)
 	{
-		case InterfaceManager::kActionFlash:
+		case Interface::kActionFlash:
 		{
 			map<string, FILE *> argumentFileMap;
 
@@ -615,20 +631,17 @@ int main(int argc, char **argv)
 				return (-1);
 			}
 
-			bool repartition = argumentMap.find(InterfaceManager::flashArgumentNames[InterfaceManager::kFlashArgRepartition]) != argumentMap.end();
+			bool repartition = argumentMap.find(Interface::actions[Interface::kActionFlash].valuelessArguments[Interface::kFlashValuelessArgRepartition]) != argumentMap.end();
 			success = attemptFlash(bridgeManager, argumentFileMap, repartition);
 
-			if (noReboot)
-				success = bridgeManager->EndSession() && success;
-			else
-				success = bridgeManager->EndSession() && bridgeManager->RebootDevice() && success;
+			success = bridgeManager->EndSession(reboot) && success;
 
 			closeFiles(argumentFileMap);
 
 			break;
 		}
 
-		case InterfaceManager::kActionClosePcScreen:
+		case Interface::kActionClosePcScreen:
 		{
 			if (!bridgeManager->BeginSession())
 			{
@@ -636,37 +649,34 @@ int main(int argc, char **argv)
 				return (-1);
 			}
 
-			InterfaceManager::Print("Attempting to close connect to pc screen...\n");
+			Interface::Print("Attempting to close connect to pc screen...\n");
 
-			if (noReboot)
-				success = bridgeManager->EndSession();
-			else
-				success = bridgeManager->EndSession() && bridgeManager->RebootDevice();
+			success = bridgeManager->EndSession(reboot);
 
 			if (success)
-				InterfaceManager::Print("Attempt complete\n");
+				Interface::Print("Attempt complete\n");
 
 			break;
 		}
 
-		case InterfaceManager::kActionDump:
+		case Interface::kActionDump:
 		{
-			const char *outputFilename = argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgOutput])->second.c_str();
+			const char *outputFilename = argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgOutput])->second.c_str();
 			FILE *dumpFile = fopen(outputFilename, "wb");
 			if (!dumpFile)
 			{
-				InterfaceManager::PrintError("Failed to open file \"%s\"\n", outputFilename);
+				Interface::PrintError("Failed to open file \"%s\"\n", outputFilename);
 
 				delete bridgeManager;
 				return (-1);
 			}
 
 			int chipType = 0;
-			string chipTypeName = argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipType])->second;
+			string chipTypeName = argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgChipType])->second;
 			if (chipTypeName == "NAND" || chipTypeName == "nand")
 				chipType = 1;
 
-			int chipId = atoi(argumentMap.find(InterfaceManager::dumpArgumentNames[InterfaceManager::kDumpArgChipId])->second.c_str());
+			int chipId = atoi(argumentMap.find(Interface::actions[Interface::kActionDump].valueArguments[Interface::kDumpValueArgChipId])->second.c_str());
 
 			if (!bridgeManager->BeginSession())
 			{
@@ -680,15 +690,12 @@ int main(int argc, char **argv)
 
 			fclose(dumpFile);
 
-			if (noReboot)
-				success = bridgeManager->EndSession() && success;
-			else
-				success = bridgeManager->EndSession() && bridgeManager->RebootDevice() && success;
+			success = bridgeManager->EndSession(reboot) && success;
 
 			break;
 		}
 
-		case InterfaceManager::kActionPrintPit:
+		case Interface::kActionPrintPit:
 		{
 			if (!bridgeManager->BeginSession())
 			{
@@ -700,11 +707,7 @@ int main(int argc, char **argv)
 
 			if (downloadPitFile(bridgeManager, &devicePit) < -1)
 			{
-				if (!bridgeManager->EndSession())
-					return (-1);
-
-				if (!noReboot)
-					bridgeManager->RebootDevice();
+				bridgeManager->EndSession(reboot);
 
 				delete bridgeManager;
 				return (-1);
@@ -714,21 +717,18 @@ int main(int argc, char **argv)
 
 			if (pitData->Unpack(devicePit))
 			{
-				pitData->Print();
+				Interface::PrintPit(pitData);
 				success = true;
 			}
 			else
 			{
-				InterfaceManager::PrintError("Failed to unpack device's PIT file!\n");
+				Interface::PrintError("Failed to unpack device's PIT file!\n");
 				success = false;
 			}
 
 			delete pitData;
 
-			if (noReboot)
-				success = bridgeManager->EndSession() && success;
-			else
-				success = bridgeManager->EndSession() && bridgeManager->RebootDevice() && success;
+			success = bridgeManager->EndSession(reboot) && success;
 
 			break;
 		}
diff --git a/heimdall/source/PitData.cpp b/libpit/Source/libpit.cpp
index 10e88b7..030a80b 100755
--- a/heimdall/source/PitData.cpp
+++ b/libpit/Source/libpit.cpp
@@ -18,12 +18,10 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.*/
 
-// Heimdall
-#include "Heimdall.h"
-#include "InterfaceManager.h"
-#include "PitData.h"
+// libpit
+#include "libpit.h"
 
-using namespace Heimdall;
+using namespace libpit;
 
 PitEntry::PitEntry()
 {
@@ -31,11 +29,11 @@ PitEntry::PitEntry()
 	partitionType = 0;
 	partitionIdentifier = 0;
 	partitionFlags = 0;
-	unknown2 = 0;
+	unknown1 = 0;
 	partitionBlockSize = 0;
 	partitionBlockCount = 0;
+	unknown2 = 0;
 	unknown3 = 0;
-	unknown4 = 0;
 
 	memset(partitionName, 0, 32);
 	memset(filename, 0, 64);
@@ -45,42 +43,6 @@ PitEntry::~PitEntry()
 {
 }
 
-void PitEntry::Print(void) const
-{
-	InterfaceManager::Print("Unused: %s\n", (unused) ? "Yes" : "No");
-
-	const char *partitionTypeText = "Unknown";
-
-	if (partitionType == PitEntry::kPartitionTypeRfs)
-		partitionTypeText = "RFS";
-	else if (partitionType == PitEntry::kPartitionTypeExt4)
-		partitionTypeText = "EXT4";
-
-	InterfaceManager::Print("Partition Type: %d (%s)\n", partitionType, partitionTypeText);
-
-	InterfaceManager::Print("Partition Identifier: %d\n", partitionIdentifier);
-
-	InterfaceManager::Print("Partition Flags: %d (", partitionFlags);
-
-	if (partitionFlags & PitEntry::kPartitionFlagWrite)
-		InterfaceManager::Print("R/W");
-	else
-		InterfaceManager::Print("R");
-
-	InterfaceManager::Print(")\n");
-
-	InterfaceManager::Print("Unknown 2: %d\n", unknown2);
-
-	InterfaceManager::Print("Partition Block Size: %d\n", partitionBlockSize);
-	InterfaceManager::Print("Partition Block Count: %d\n", partitionBlockCount);
-
-	InterfaceManager::Print("Unknown 3: %d\n", unknown3);
-	InterfaceManager::Print("Unknown 4: %d\n", unknown4);
-
-	InterfaceManager::Print("Partition Name: %s\n", partitionName);
-	InterfaceManager::Print("Filename: %s\n", filename);
-}
-
 
 
 PitData::PitData()
@@ -153,7 +115,7 @@ bool PitData::Unpack(const unsigned char *data)
 		entries[i]->SetPartitionFlags(integerValue);
 
 		integerValue = PitData::UnpackInteger(data, entryOffset + 16);
-		entries[i]->SetUnknown2(integerValue);
+		entries[i]->SetUnknown1(integerValue);
 
 		integerValue = PitData::UnpackInteger(data, entryOffset + 20);
 		entries[i]->SetPartitionBlockSize(integerValue);
@@ -162,10 +124,10 @@ bool PitData::Unpack(const unsigned char *data)
 		entries[i]->SetPartitionBlockCount(integerValue);
 
 		integerValue = PitData::UnpackInteger(data, entryOffset + 28);
-		entries[i]->SetUnknown3(integerValue);
+		entries[i]->SetUnknown2(integerValue);
 
 		integerValue = PitData::UnpackInteger(data, entryOffset + 32);
-		entries[i]->SetUnknown4(integerValue);
+		entries[i]->SetUnknown3(integerValue);
 
 		entries[i]->SetPartitionName((const char *)data + entryOffset + 36);
 		entries[i]->SetFilename((const char *)data + entryOffset + 36 + PitEntry::kPartitionNameMaxLength);
@@ -204,24 +166,56 @@ void PitData::Pack(unsigned char *data) const
 		PitData::PackInteger(data, entryOffset + 8, entries[i]->GetPartitionIdentifier());
 		PitData::PackInteger(data, entryOffset + 12, entries[i]->GetPartitionFlags());
 
-		PitData::PackInteger(data, entryOffset + 16, entries[i]->GetUnknown2());
+		PitData::PackInteger(data, entryOffset + 16, entries[i]->GetUnknown1());
 
 		PitData::PackInteger(data, entryOffset + 20, entries[i]->GetPartitionBlockSize());
 		PitData::PackInteger(data, entryOffset + 24, entries[i]->GetPartitionBlockCount());
 
-		PitData::PackInteger(data, entryOffset + 28, entries[i]->GetUnknown3());
-		PitData::PackInteger(data, entryOffset + 32, entries[i]->GetUnknown4());
+		PitData::PackInteger(data, entryOffset + 28, entries[i]->GetUnknown2());
+		PitData::PackInteger(data, entryOffset + 32, entries[i]->GetUnknown3());
 
 		memcpy(data + entryOffset + 36, entries[i]->GetPartitionName(), PitEntry::kPartitionNameMaxLength);
 		memcpy(data + entryOffset + 36 + PitEntry::kPartitionNameMaxLength, entries[i]->GetPartitionName(), PitEntry::kFilenameMaxLength);
 	}
 }
 
+void PitData::Clear(void)
+{
+	entryCount = 0;
+
+	unknown1 = 0;
+	unknown2 = 0;
+
+	unknown3 = 0;
+	unknown4 = 0;
+
+	unknown5 = 0;
+	unknown6 = 0;
+
+	unknown7 = 0;
+	unknown8 = 0;
+
+	for (unsigned int i = 0; i < entries.size(); i++)
+		delete entries[i];
+
+	entries.clear();
+}
+
+PitEntry *PitData::GetEntry(unsigned int index)
+{
+	return (entries[index]);
+}
+
+const PitEntry *PitData::GetEntry(unsigned int index) const
+{
+	return (entries[index]);
+}
+
 PitEntry *PitData::FindEntry(const char *partitionName)
 {
 	for (unsigned int i = 0; i < entries.size(); i++)
 	{
-		if (strcmp(entries[i]->GetPartitionName(), partitionName) == 0)
+		if (!entries[i]->GetUnused() && strcmp(entries[i]->GetPartitionName(), partitionName) == 0)
 			return (entries[i]);
 	}
 
@@ -232,7 +226,7 @@ const PitEntry *PitData::FindEntry(const char *partitionName) const
 {
 	for (unsigned int i = 0; i < entries.size(); i++)
 	{
-		if (strcmp(entries[i]->GetPartitionName(), partitionName) == 0)
+		if (!entries[i]->GetUnused() && strcmp(entries[i]->GetPartitionName(), partitionName) == 0)
 			return (entries[i]);
 	}
 
@@ -243,7 +237,7 @@ PitEntry *PitData::FindEntry(unsigned int partitionIdentifier)
 {
 	for (unsigned int i = 0; i < entries.size(); i++)
 	{
-		if (entries[i]->GetPartitionIdentifier() == partitionIdentifier)
+		if (!entries[i]->GetUnused() && entries[i]->GetPartitionIdentifier() == partitionIdentifier)
 			return (entries[i]);
 	}
 
@@ -254,31 +248,9 @@ const PitEntry *PitData::FindEntry(unsigned int partitionIdentifier) const
 {
 	for (unsigned int i = 0; i < entries.size(); i++)
 	{
-		if (entries[i]->GetPartitionIdentifier() == partitionIdentifier)
+		if (!entries[i]->GetUnused() && entries[i]->GetPartitionIdentifier() == partitionIdentifier)
 			return (entries[i]);
 	}
 
 	return (nullptr);
 }
-
-void PitData::Print(void) const
-{
-	InterfaceManager::Print("Entry Count: %d\n", entryCount);
-
-	InterfaceManager::Print("Unknown 1: %d\n", unknown1);
-	InterfaceManager::Print("Unknown 2: %d\n", unknown2);
-	InterfaceManager::Print("Unknown 3: %d\n", unknown3);
-	InterfaceManager::Print("Unknown 4: %d\n", unknown4);
-	InterfaceManager::Print("Unknown 5: %d\n", unknown5);
-	InterfaceManager::Print("Unknown 6: %d\n", unknown6);
-	InterfaceManager::Print("Unknown 7: %d\n", unknown7);
-	InterfaceManager::Print("Unknown 8: %d\n", unknown8);
-
-	for (unsigned int i = 0; i < entryCount; i++)
-	{
-		InterfaceManager::Print("\n\n--- Entry #%d ---\n", i);
-		entries[i]->Print();
-	}
-
-	InterfaceManager::Print("\n");
-}
diff --git a/heimdall/source/PitData.h b/libpit/Source/libpit.h
index b6a0d2f..636f1e1 100755
--- a/heimdall/source/PitData.h
+++ b/libpit/Source/libpit.h
@@ -18,14 +18,14 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.*/
 
-#ifndef PITDATA_H
-#define PITDATA_H
+#ifndef LIBPIT_H
+#define LIBPIT_H
 
 // C Standard Library
 #include <string.h>
 #include <vector>
 
-namespace Heimdall
+namespace libpit
 {
 	class PitEntry
 	{
@@ -58,13 +58,13 @@ namespace Heimdall
 			unsigned int partitionIdentifier;
 			unsigned int partitionFlags;
 
-			unsigned int unknown2;
+			unsigned int unknown1;
 
 			unsigned int partitionBlockSize;
 			unsigned int partitionBlockCount;
 
+			unsigned int unknown2;
 			unsigned int unknown3;
-			unsigned int unknown4;
 
 			char partitionName[kPartitionNameMaxLength];
 			char filename[kFilenameMaxLength];
@@ -74,8 +74,6 @@ namespace Heimdall
 			PitEntry();
 			~PitEntry();
 
-			void Print(void) const;
-
 			bool GetUnused(void) const
 			{
 				return unused;
@@ -116,14 +114,14 @@ namespace Heimdall
 				this->partitionFlags = partitionFlags;
 			}
 
-			unsigned int GetUnknown2(void) const
+			unsigned int GetUnknown1(void) const
 			{
-				return unknown2;
+				return unknown1;
 			}
 
-			void SetUnknown2(unsigned int unknown2)
+			void SetUnknown1(unsigned int unknown1)
 			{
-				this->unknown2 = unknown2;
+				this->unknown1 = unknown1;
 			}
 
 			unsigned int GetPartitionBlockSize(void) const
@@ -146,24 +144,24 @@ namespace Heimdall
 				this->partitionBlockCount = partitionBlockCount;
 			}
 
-			unsigned int GetUnknown3(void) const
+			unsigned int GetUnknown2(void) const
 			{
-				return unknown3;
+				return unknown2;
 			}
 
-			void SetUnknown3(unsigned int unknown3)
+			void SetUnknown2(unsigned int unknown2)
 			{
-				this->unknown3 = unknown3;
+				this->unknown2 = unknown2;
 			}
 
-			unsigned int GetUnknown4(void) const
+			unsigned int GetUnknown3(void) const
 			{
-				return unknown4;
+				return unknown3;
 			}
 
-			void SetUnknown4(unsigned int unknown4)
+			void SetUnknown3(unsigned int unknown3)
 			{
-				this->unknown4 = unknown4;
+				this->unknown3 = unknown3;
 			}
 
 			const char *GetPartitionName(void) const
@@ -287,14 +285,17 @@ namespace Heimdall
 			bool Unpack(const unsigned char *data);
 			void Pack(unsigned char *data) const;
 
+			void Clear(void);
+
+			PitEntry *GetEntry(unsigned int index);
+			const PitEntry *GetEntry(unsigned int index) const;
+
 			PitEntry *FindEntry(const char *partitionName);
 			const PitEntry *FindEntry(const char *partitionName) const;
 
 			PitEntry *FindEntry(unsigned int partitionIdentifier);
 			const PitEntry *FindEntry(unsigned int partitionIdentifier) const;
 
-			void Print(void) const;
-
 			unsigned int GetEntryCount(void) const
 			{
 				return entryCount;
diff --git a/libpit/libpit.vcxproj b/libpit/libpit.vcxproj
new file mode 100755
index 0000000..af828bc
--- /dev/null
+++ b/libpit/libpit.vcxproj
@@ -0,0 +1,119 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release - Static MSVC|Win32">
+      <Configuration>Release - Static MSVC</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Source\libpit.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Source\libpit.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>libpit</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\lib\</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\lib\</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\lib\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release - Static MSVC|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/libpit/libpit.vcxproj.filters b/libpit/libpit.vcxproj.filters
new file mode 100755
index 0000000..c9ea499
--- /dev/null
+++ b/libpit/libpit.vcxproj.filters
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Source\libpit.h">
+      <Filter>Source</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Source\libpit.cpp">
+      <Filter>Source</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/msvc2010.sln b/msvc2010.sln
index b688da2..f5d5172 100644
--- a/msvc2010.sln
+++ b/msvc2010.sln
@@ -1,18 +1,22 @@
 

 Microsoft Visual Studio Solution File, Format Version 11.00

-# Visual C++ Express 2010

+# Visual Studio 2010

 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "heimdall-frontend", "heimdall-frontend\heimdall-frontend.vcxproj", "{EAD352DF-7CDE-478C-8D70-B0E42A951DEF}"

 	ProjectSection(ProjectDependencies) = postProject

 		{DC0D782C-8DB7-44CA-A984-D3A97483E0D0} = {DC0D782C-8DB7-44CA-A984-D3A97483E0D0}

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D} = {9506FFE4-3A78-4BEE-A15E-62C5A138E61D}

 	EndProjectSection

 EndProject

 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "heimdall", "heimdall\heimdall.vcxproj", "{DC0D782C-8DB7-44CA-A984-D3A97483E0D0}"

 	ProjectSection(ProjectDependencies) = postProject

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D} = {9506FFE4-3A78-4BEE-A15E-62C5A138E61D}

 		{349EE8F9-7D25-4909-AAF5-FF3FADE72187} = {349EE8F9-7D25-4909-AAF5-FF3FADE72187}

 	EndProjectSection

 EndProject

 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libusb-1.0 (static)", "libusb-1.0\_libusb_static_2010.vcxproj", "{349EE8F9-7D25-4909-AAF5-FF3FADE72187}"

 EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libpit", "libpit\libpit.vcxproj", "{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}"

+EndProject

 Global

 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

 		Debug|Win32 = Debug|Win32

@@ -53,6 +57,15 @@ Global
 		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|Win32.Build.0 = Release|Win32

 		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|x64.ActiveCfg = Release|x64

 		{349EE8F9-7D25-4909-AAF5-FF3FADE72187}.Release|x64.Build.0 = Release|x64

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Debug|Win32.ActiveCfg = Debug|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Debug|Win32.Build.0 = Debug|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Debug|x64.ActiveCfg = Debug|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Release - Static MSVC|Win32.ActiveCfg = Release - Static MSVC|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Release - Static MSVC|Win32.Build.0 = Release - Static MSVC|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Release - Static MSVC|x64.ActiveCfg = Release|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Release|Win32.ActiveCfg = Release|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Release|Win32.Build.0 = Release|Win32

+		{9506FFE4-3A78-4BEE-A15E-62C5A138E61D}.Release|x64.ActiveCfg = Release|Win32

 	EndGlobalSection

 	GlobalSection(SolutionProperties) = preSolution

 		HideSolutionNode = FALSE