haiku/src/apps/packageinstaller/PackageInfo.cpp

/*
 * Copyright (c) 2007-2010, Haiku, Inc.
 * Distributed under the terms of the MIT license.
 *
 * Author:
 *		Łukasz 'Sil2100' Zemczak <sil2100@vexillium.org>
 */


#include "PackageInfo.h"

#include <Alert.h>
#include <ByteOrder.h>
#include <Catalog.h>
#include <FindDirectory.h>
#include <Locale.h>
#include <Path.h>
#include <kernel/OS.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PackageInfo"

#define RETURN_AND_SET_STATUS(err) fStatus = err; \
	fprintf(stderr, "err at %s():%d: %x\n", __FUNCTION__, __LINE__, err); \
	return fStatus;

const uint32 kSkipOffset = 33;

// Section constants
enum {
	P_GROUPS_SECTION = 0,
	P_PATH_SECTION,
	P_USER_PATH_SECTION,
	P_LICENSE_SECTION
};


// Element constants
enum {
	P_NONE = 0,
	P_FILE,
	P_DIRECTORY,
	P_LINK,
	P_SCRIPT
};

typedef enum {
	B_BEBOX_PLATFORM = 0,
	B_MAC_PLATFORM,
	B_AT_CLONE_PLATFORM,
	B_ENIAC_PLATFORM,
	B_APPLE_II_PLATFORM,
	B_CRAY_PLATFORM,
	B_LISA_PLATFORM,
	B_TI_994A_PLATFORM,
	B_TIMEX_SINCLAIR_PLATFORM,
	B_ORAC_1_PLATFORM,
	B_HAL_PLATFORM,
	B_INVALID_PLATFORM
} platform_type;


PackageInfo::PackageInfo()
	:
	fStatus(B_NO_INIT),
	fPackageFile(0),
	fDescription(B_TRANSLATE("No package available.")),
	fProfiles(2),
	fHasImage(false)
{
}


PackageInfo::PackageInfo(const entry_ref *ref)
	:
	fStatus(B_NO_INIT),
	fPackageFile(new BFile(ref, B_READ_ONLY)),
	fDescription(B_TRANSLATE("No package selected.")),
	fProfiles(2),
	fHasImage(false)
{
	fStatus = Parse();
}


PackageInfo::~PackageInfo()
{
	pkg_profile *iter = 0;
	while (1) {
		iter = static_cast<pkg_profile *>(fProfiles.RemoveItem((int32)0));
		if (iter == NULL)
			break;

		delete iter;
	}

	PackageItem *file = 0;
	while (true) {
		file = static_cast<PackageItem *>(fFiles.RemoveItem((int32)0));
		if (file == NULL)
			break;

		delete file;
	}

	while (true) {
		file = static_cast<PackageScript *>(fScripts.RemoveItem((int32)0));
		if (file == NULL)
			break;

		delete file;
	}

	delete fPackageFile;
}


status_t
PackageInfo::Parse()
{
	// TODO: Clean up
	if (!fPackageFile || fPackageFile->InitCheck() != B_OK) {
		RETURN_AND_SET_STATUS(B_ERROR);
	}

	// Check for the presence of the first AlB tag - as the 'magic number'.
	// This also ensures that the file header section is present - which
	// is a crucial pkg section
	char buffer[16];
	fPackageFile->Read(buffer, 8);
	if (buffer[0] != 'A' || buffer[1] != 'l' || buffer[2] != 'B'
		|| buffer[3] != 0x1a) {
		RETURN_AND_SET_STATUS(B_ERROR);
	}

	fHasImage = false;

	// Parse all known parts of the given .pkg file

	uint32 i;
	int8 bytesRead;
	off_t actualSize = 0;
	fPackageFile->GetSize(&actualSize);
	uint64 fileSize = 0;

	const char padding[7] = { 0, 0, 0, 0, 0, 0, 0 };

	platform_type thisPlatform = B_INVALID_PLATFORM;
	cpu_topology_node_info topologyRoot;
	uint32 topologyNodeCount = 1;
	if (get_cpu_topology_info(&topologyRoot, &topologyNodeCount) == B_OK) {
		switch (topologyRoot.data.root.platform) {
			case B_CPU_x86:
				thisPlatform = B_AT_CLONE_PLATFORM;
				break;

			default:
				break;
		}
	}

	uint64 infoOffset = 0, groupsOffset = 0;
	uint64 length = 0;

	// Parse the file header
	while (true) {
		bytesRead = fPackageFile->Read(buffer, 7);
		if (bytesRead != 7) {
			RETURN_AND_SET_STATUS(B_ERROR);
		}

		if (!memcmp(buffer, "PhIn", 5)) {
		} else if (!memcmp(buffer, "FVer", 5)) {
			// Not used right now
			fPackageFile->Seek(4, SEEK_CUR);
			parser_debug("FVer\n");
		} else if (!memcmp(buffer, "AFla", 5)) {
			// Not used right now TODO: Check what this tag is for
			fPackageFile->Seek(8, SEEK_CUR);
			parser_debug("AFla\n");
		} else if (!memcmp(buffer, "FSiz", 5)) {
			fPackageFile->Read(&fileSize, 8);
			swap_data(B_UINT64_TYPE, &fileSize, sizeof(uint64),
					B_SWAP_BENDIAN_TO_HOST);
			parser_debug("FSiz %llu\n", fileSize);
		} else if (!memcmp(buffer, "COff", 5)) {
			fPackageFile->Read(&infoOffset, 8);
			swap_data(B_UINT64_TYPE, &infoOffset, sizeof(uint64),
					B_SWAP_BENDIAN_TO_HOST);
			parser_debug("COff %llu\n", infoOffset);
		} else if (!memcmp(buffer, "AOff", 5)) {
			fPackageFile->Read(&groupsOffset, 8);
			swap_data(B_UINT64_TYPE, &groupsOffset, sizeof(uint64),
					B_SWAP_BENDIAN_TO_HOST);
			parser_debug("AOff %llu\n", groupsOffset);
		} else if (!memcmp(buffer, padding, 7)) {
			// This means the end of this section - we should move to the
			// groups section.
			if (groupsOffset) {
				fPackageFile->Seek(groupsOffset, SEEK_SET);
			}
			parser_debug("End!\n");
			break;
		} else {
			RETURN_AND_SET_STATUS(B_ERROR);
		}
	}

	fPackageFile->Read(buffer, 7);
	if (memcmp(buffer, "PkgA", 5) || !groupsOffset || !infoOffset) {
		RETURN_AND_SET_STATUS(B_ERROR);
	}

	// Section header identifying constant byte sequences:
	const char groupsMarker[7] = { 0, 0, 0, 1, 0, 0, 4 };
	const char idMarker[7] = { 0, 0, 0, 2, 0, 0, 4 };
	const char pathMarker[7] = { 0, 0, 0, 3, 0, 0, 4 };
	const char upathMarker[7] = { 0, 0, 0, 4, 0, 0, 4 };
	const char licenseMarker[7] = { 0, 0, 0, 18, 0, 0, 4 };
	const char descMarker[7] = { 0, 0, 0, 5, 0, 0, 2 };
	const char helpMarker[7] = { 0, 0, 0, 10, 0, 0, 3 };

	const char splashScreenMarker[7] = { 0, 0, 0, 8, 0, 0, 3 };
	const char disclaimerMarker[7] = { 0, 0, 0, 7, 0, 0, 3 };

	const char nameMarker[7] = { 0, 0, 0, 13, 0, 0, 2 };
	const char versionMarker[7] = { 0, 0, 0, 14, 0, 0, 2 };
	const char devMarker[7] = { 0, 0, 0, 15, 0, 0, 2 };
	const char shortDescMarker[7] = { 0, 0, 0, 17, 0, 0, 2 };

	int8 section = P_GROUPS_SECTION, installDirectoryFlag = 0;

	pkg_profile group;
	BList groups(3), userPaths(3), systemPaths(10);
	bool groupStarted = false;
	parser_debug("Package Info reached!\n");
	// TODO: Maybe checking whether the needed number of bytes are read
	//	everytime would be a good idea

	// Parse the package info section
	while (true) {
		bytesRead = fPackageFile->Read(buffer, 7);
		if (bytesRead != 7) {
			parser_debug("EOF!\n");
			break;
		}

		if (!memcmp(buffer, groupsMarker, 7)) {
			section = P_GROUPS_SECTION;
			parser_debug("Got to Groups section\n");
			continue;
		} else if (!memcmp(buffer, pathMarker, 7)) {
			section = P_PATH_SECTION;
			parser_debug("Got to System Paths\n");
			continue;
		} else if (!memcmp(buffer, upathMarker, 7)) {
			section = P_USER_PATH_SECTION;
			parser_debug("Got to User Paths\n");
			continue;
		} else if (!memcmp(buffer, licenseMarker, 7)) {
			section = P_LICENSE_SECTION;
			parser_debug("Got to License\n");
			continue;
			// After this, non sectioned tags follow
		} else if (!memcmp(buffer, disclaimerMarker, 7)) {
			uint64 length;
			fPackageFile->Read(&length, 8);
			swap_data(B_UINT64_TYPE, &length, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);

			uint64 original;
			if (fPackageFile->Read(&original, 8) != 8) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}
			swap_data(B_UINT64_TYPE, &original, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);

			fPackageFile->Seek(4, SEEK_CUR);

			uint8 *compressed = new uint8[length];
			if (fPackageFile->Read(compressed, length)
					!= static_cast<int64>(length)) {
				delete[] compressed;
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			uint8 *disclaimer = new uint8[original + 1];
			status_t ret = inflate_data(compressed, length, disclaimer,
				original);
			disclaimer[original] = 0;
			delete[] compressed;
			if (ret != B_OK) {
				delete[] disclaimer;
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			fDisclaimer = (char *)disclaimer;
			delete[] disclaimer;

			continue;
		} else if (!memcmp(buffer, splashScreenMarker, 7)) {
			uint64 length;
			fPackageFile->Read(&length, 8);
			swap_data(B_UINT64_TYPE, &length, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);

			uint64 original;
			if (fPackageFile->Read(&original, 8) != 8) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}
			swap_data(B_UINT64_TYPE, &original, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);

			fPackageFile->Seek(4, SEEK_CUR);

			uint8 *compressed = new uint8[length];
			if (fPackageFile->Read(compressed, length)
					!= static_cast<int64>(length)) {
				delete[] compressed;
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			fImage.SetSize(original);
			status_t ret = inflate_data(compressed, length,
				static_cast<uint8 *>(const_cast<void *>(fImage.Buffer())),
				original);
			delete[] compressed;
			if (ret != B_OK) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}
			fHasImage = true;
			continue;
		}

		switch (section) {
			case P_PATH_SECTION:
			{
				if (!memcmp(buffer, "DPat", 5)) {
					parser_debug("DPat\n");
					continue;
				} else if (!memcmp(buffer, "FDst", 5)) {
					parser_debug("FDst - ");
					directory_which dir;
					if (fPackageFile->Read(&dir, 4) != 4) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}
					swap_data(B_UINT32_TYPE, &dir, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);
					BPath *path = new BPath();
					status_t ret = find_directory(dir, path);
					if (ret != B_OK) {
						delete path;
						RETURN_AND_SET_STATUS(B_ERROR);
					}

					parser_debug("%s\n", path->Path());

					systemPaths.AddItem(path);
				} else if (!memcmp(buffer, "PaNa", 5)) {
					parser_debug("PaNa\n");
					if (fPackageFile->Read(&length, 4) != 4) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);
					// Since its a default, system path, we can ignore the path
					// name - all information needed is beside the FDst tag.
					fPackageFile->Seek(length, SEEK_CUR);
				} else if (!memcmp(buffer, padding, 7)) {
					parser_debug("Padding!\n");
					continue;
				} else {
					RETURN_AND_SET_STATUS(B_ERROR);
				}
				break;
			}

			case P_GROUPS_SECTION:
			{
				if (!memcmp(buffer, "IGrp", 5)) {
					// Creata a new group
					groupStarted = true;
					group = pkg_profile();
					parser_debug("IGrp\n");
				} else if (!memcmp(buffer, "GrpN", 5)) {
					if (!groupStarted) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}

					parser_debug("GrpN\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *name = new char[length + 1];
					fPackageFile->Read(name, length);
					name[length] = 0;
					group.name = name;
					delete[] name;
				} else if (!memcmp(buffer, "GrpD", 5)) {
					if (!groupStarted) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}

					parser_debug("GrpD\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *desc = new char[length + 1];
					fPackageFile->Read(desc, length);
					desc[length] = 0;
					group.description = desc;
					delete[] desc;
				} else if (!memcmp(buffer, "GrHt", 5)) {
					if (!groupStarted) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}

					parser_debug("GrHt\n");
					// For now, we don't need group help
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);
					fPackageFile->Seek(length, SEEK_CUR);
				} else if (!memcmp(buffer, padding, 5)) {
					if (!groupStarted) {
						parser_debug("No group - padding!\n");
						continue;
					}

					fProfiles.AddItem(new pkg_profile(group));
					parser_debug("Group added: %s %s\n", group.name.String(),
						group.description.String());

					groupStarted = false;
				} else if (!memcmp(buffer, "GrId", 5)) {
					uint32 id;
					fPackageFile->Read(&id, 4);
					swap_data(B_UINT32_TYPE, &id, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					parser_debug("GrId\n");

					if (id == 0xffffffff)
						groups.AddItem(NULL);
					else
						groups.AddItem(fProfiles.ItemAt(id));
				} else if (!memcmp(buffer, idMarker, 7)
					|| !memcmp(buffer, groupsMarker, 7)) {
					parser_debug("Marker, jumping!\n");
					continue;
				} else {
					RETURN_AND_SET_STATUS(B_ERROR);
				}
				break;
			}

			case P_LICENSE_SECTION:
			{
				if (!memcmp(buffer, "Lic?", 5)) {
					parser_debug("Lic?\n");
					// This tag informs whether a license is present in the
					// package or not. Since we don't care about licenses right
					// now, just skip this section
					fPackageFile->Seek(4, SEEK_CUR);
				} else if (!memcmp(buffer, "LicP", 5)) {
					parser_debug("LicP\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					fPackageFile->Seek(length, SEEK_CUR);
				} else if (!memcmp(buffer, padding, 7)) {
					continue;
				} else if (!memcmp(buffer, descMarker, 7)) {
					parser_debug("Description text reached\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *description = new char[length + 1];
					fPackageFile->Read(description, length);
					description[length] = 0;
					fDescription = description;

					// Truncate all leading newlines
					for (i = 0; i < length; i++) {
						if (fDescription[i] != '\n')
							break;
					}
					fDescription.Remove(0, i);

					delete[] description;
					parser_debug("Description text reached\n");

					// After this, there's a known size sequence of bytes, which
					// meaning is yet to be determined.

					// One is already known. The byte (or just its least
					// significant bit) at offset 21 from the description text
					// is responsible for the install folder existence
					// information. If it is 0, there is no install folder, if
					// it is 1 (or the least significant bit is set) it means
					// we should install all 0xffffffff files/directories to
					// the first directory existing in the package
					fPackageFile->Seek(21, SEEK_CUR);
					if (fPackageFile->Read(&installDirectoryFlag, 1) != 1) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}

					fPackageFile->Seek(11, SEEK_CUR);
				} else if (!memcmp(buffer, nameMarker, 7)) {
					parser_debug("Package name reached\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *name = new char[length + 1];
					fPackageFile->Read(name, length);
					name[length] = 0;
					fName = name;
					delete[] name;
				} else if (!memcmp(buffer, versionMarker, 7)) {
					parser_debug("Package version reached\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *version = new char[length + 1];
					fPackageFile->Read(version, length);
					version[length] = 0;
					fVersion = version;
					delete[] version;
				} else if (!memcmp(buffer, devMarker, 7)) {
					parser_debug("Package developer reached\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *dev = new char[length + 1];
					fPackageFile->Read(dev, length);
					dev[length] = 0;
					fDeveloper = dev;
					delete[] dev;
				} else if (!memcmp(buffer, shortDescMarker, 7)) {
					parser_debug("Package short description reached\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *desc = new char[length + 1];
					fPackageFile->Read(desc, length);
					desc[length] = 0;
					fShortDesc = desc;
					delete[] desc;
				} else if (!memcmp(buffer, helpMarker, 7)) {
					// The help text is a stored in deflated state, preceded by a 64 bit
					// compressed size, 64 bit inflated size and a 32 bit integer
					// Since there was no discussion whether we need this help text,
					// it will be skipped
					parser_debug("Help text reached\n");
					//uint64 length64;
					fPackageFile->Read(&length, 8);
					swap_data(B_UINT64_TYPE, &length, sizeof(uint64),
						B_SWAP_BENDIAN_TO_HOST);

					fPackageFile->Seek(12 + length, SEEK_CUR);
				}
				break;
			}

			case P_USER_PATH_SECTION:
			{
				if (!memcmp(buffer, "DPat", 5)) {
					parser_debug("DPat\n");
					continue;
				} else if (!memcmp(buffer, "DQue", 5)) {
					parser_debug("DQue\n");
					continue;
				} else if (!memcmp(buffer, "DQTi", 5)) {
					parser_debug("DQTi\n");
					uint32 length;
					if (fPackageFile->Read(&length, 4) != 4) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);
					char *ti = new char[length + 1];
					fPackageFile->Read(ti, length);
					ti[length] = 0;
					parser_debug("DQTi - %s\n", ti);
					delete[] ti;
				} else if (!memcmp(buffer, "DQSz", 5)) {
					parser_debug("DQSz\n");
					uint64 size;
					if (fPackageFile->Read(&size, 8) != 8) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}
					swap_data(B_UINT64_TYPE, &size, sizeof(uint64),
						B_SWAP_BENDIAN_TO_HOST);
					parser_debug("DQSz - %Ld\n", size);
				} else if (!memcmp(buffer, "DQMi", 5)) {
					// TODO actually check if the query finds a file with
					// size found previously
					parser_debug("DQMi\n");
					uint32 length;
					if (fPackageFile->Read(&length, 4) != 4) {
						RETURN_AND_SET_STATUS(B_ERROR);
					}
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);
					char *signature = new char[length + 1];
					fPackageFile->Read(signature, length);
					signature[length] = 0;
					parser_debug("DQMi - %s\n", signature);
					delete[] signature;
				} else if (!memcmp(buffer, "PaNa", 5)) {
					parser_debug("PaNa\n");
					fPackageFile->Read(&length, 4);
					swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
						B_SWAP_BENDIAN_TO_HOST);

					char *pathname = new char[length + 1];
					fPackageFile->Read(pathname, length);
					pathname[length] = 0;
					BString *path = new BString(pathname);
					if (length > 0 && pathname[length - 1] == '/')
						path->Remove(length - 1, 1);
					userPaths.AddItem(path);
					delete[] pathname;
				} else if (!memcmp(buffer, padding, 7)) {
					parser_debug("Padding!\n");
					continue;
				} else {
					parser_debug("Unknown user path section %s\n", buffer);
					RETURN_AND_SET_STATUS(B_ERROR);
				}
				break;
			}
		}
	}

	BString nameString, mimeString, signatureString, linkString;
	BString itemPath = "", installDirectory = "";
	uint32 directoryCount = 0;

	uint8 element = P_NONE;
	uint32 itemGroups = 0, path = 0, cust = 0, ctime = 0, mtime = 0;
	uint32 platform = 0xffffffff;
	uint64 offset = 0, size = 0, originalSize = 0, mode = 0;
	uint8 pathType = P_INSTALL_PATH;
	status_t ret;

	fPackageFile->Seek(infoOffset, SEEK_SET);

	// Parse package file data
	while (true) {
		bytesRead = fPackageFile->Read(buffer, 7);
		if (bytesRead != 7) {
			RETURN_AND_SET_STATUS(B_ERROR);
		}

#define INIT_VARS(tag, type) \
		parser_debug(tag "\n"); \
		element = type; \
		mimeString = ""; \
		nameString = ""; \
		linkString = ""; \
		signatureString = ""; \
		itemGroups = 0; \
		ctime = 0; \
		mtime = 0; \
		offset = 0; \
		cust = 0; \
		mode = 0; \
		platform = 0xffffffff; \
		size = 0; \
		originalSize = 0

		if (!memcmp(buffer, "FilI", 5)) {
			INIT_VARS("FilI", P_FILE);
		} else if (!memcmp(buffer, "FldI", 5)) {
			INIT_VARS("FldI", P_DIRECTORY);
		} else if (!memcmp(buffer, "LnkI", 5)) {
			INIT_VARS("LnkI", P_LINK);
		} else if (!memcmp(buffer, "ScrI", 5)) {
			INIT_VARS("ScrI", P_SCRIPT);
		} else if (!memcmp(buffer, "Name", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Name\n");
			fPackageFile->Read(&length, 4);
			swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);

			char *name = new char[length + 1];
			fPackageFile->Read(name, length);
			name[length] = 0;

			nameString = name;
			delete[] name;
		} else if (!memcmp(buffer, "Grps", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Grps\n");
			fPackageFile->Read(&itemGroups, 4);
			swap_data(B_UINT32_TYPE, &itemGroups, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "Dest", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Dest\n");
			fPackageFile->Read(&path, 4);
			swap_data(B_UINT32_TYPE, &path, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "Cust", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Cust\n");
			fPackageFile->Read(&cust, 4);
			swap_data(B_UINT32_TYPE, &cust, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "Repl", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Repl\n");
			fPackageFile->Seek(4, SEEK_CUR);
			// TODO: Should the replace philosophy depend on this flag? For now
			//	I always leave the decision to the user
		} else if (!memcmp(buffer, "Plat", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Plat\n");
			fPackageFile->Read(&platform, 4);
			swap_data(B_UINT32_TYPE, &platform, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "CTim", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("CTim\n");
			fPackageFile->Read(&ctime, 4);
			swap_data(B_UINT32_TYPE, &ctime, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "MTim", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("MTim\n");
			fPackageFile->Read(&mtime, 4);
			swap_data(B_UINT32_TYPE, &mtime, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "OffT", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("OffT\n");
			fPackageFile->Read(&offset, 8);
			swap_data(B_UINT64_TYPE, &offset, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "Mime", 5)) {
			if (element != P_FILE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			fPackageFile->Read(&length, 4);
			swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);

			char *mime = new char[length + 1];
			fPackageFile->Read(mime, length);
			mime[length] = 0;
			parser_debug("Mime: %s\n", mime);

			mimeString = mime;
			delete[] mime;
		} else if (!memcmp(buffer, "CmpS", 5)) {
			if (element == P_NONE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("CmpS\n");
			fPackageFile->Read(&size, 8);
			swap_data(B_UINT64_TYPE, &size, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "OrgS", 5)) {
			if (element != P_FILE && element != P_LINK && element != P_SCRIPT) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("OrgS\n");
			fPackageFile->Read(&originalSize, 8);
			swap_data(B_UINT64_TYPE, &originalSize, sizeof(uint64),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "VrsI", 5)) {
			if (element != P_FILE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("VrsI\n");
			fPackageFile->Seek(24, SEEK_CUR);
			// TODO
			// Also, check what those empty 20 bytes mean
		} else if (!memcmp(buffer, "Mode", 5)) {
			if (element != P_FILE && element != P_LINK) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("Mode\n");
			fPackageFile->Read(&mode, 4);
			swap_data(B_UINT32_TYPE, &mode, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);
		} else if (!memcmp(buffer, "FDat", 5)) {
			if (element != P_DIRECTORY) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			parser_debug("FDat\n");
		} else if (!memcmp(buffer, "ASig", 5)) {
			if (element != P_FILE) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			fPackageFile->Read(&length, 4);
			swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);

			char *signature = new char[length + 1];
			fPackageFile->Read(signature, length);
			signature[length] = 0;
			parser_debug("Signature: %s\n", signature);

			signatureString = signature;
			delete[] signature;
		} else if (!memcmp(buffer, "Link", 5)) {
			if (element != P_LINK) {
				RETURN_AND_SET_STATUS(B_ERROR);
			}

			fPackageFile->Read(&length, 4);
			swap_data(B_UINT32_TYPE, &length, sizeof(uint32),
				B_SWAP_BENDIAN_TO_HOST);

			char *link = new char[length + 1];
			fPackageFile->Read(link, length);
			link[length] = 0;
			parser_debug("Link: %s\n", link);

			linkString = link;
			delete[] link;
		} else if (!memcmp(buffer, padding, 7)) {
			PackageItem *item = NULL;

			parser_debug("Padding!\n");
			if (platform != 0xffffffff
				&& static_cast<platform_type>(platform) != thisPlatform) {
				// If the file/directory/item's platform is different than the
				// target platform (or different than the 'any' constant),
				// ignore this file
			} else if (element == P_FILE) {
				if (itemGroups && offset && size) {
					BString dest = "";
					uint8 localType = pathType;

					if (path == 0xfffffffe)
						dest << itemPath << "/" << nameString.String();
					else if (path == 0xffffffff) {
						localType = P_INSTALL_PATH;
						dest = installDirectory;
						dest << nameString;
					} else {
						if (cust) {
							BString *def = static_cast<BString *>(
								userPaths.ItemAt(path));
							if (!def) {
								RETURN_AND_SET_STATUS(B_ERROR);
							}
							if ((*def)[0] == '/')
								localType = P_SYSTEM_PATH;
							else
								localType = P_USER_PATH;

							dest << *def << "/" << nameString;
						} else {
							BPath *def = static_cast<BPath *>(
								systemPaths.ItemAt(path));
							if (!def) {
								RETURN_AND_SET_STATUS(B_ERROR);
							}
							localType = P_SYSTEM_PATH;

							dest << def->Path() << "/" << nameString;
						}
					}

					parser_debug("Adding file: %s!\n", dest.String());

					item = new PackageFile(fPackageFile, dest, localType, ctime,
						mtime, offset, size, originalSize, 0, mimeString,
						signatureString, mode);
				}
			} else if (element == P_DIRECTORY) {
				if (itemGroups) {
					if (installDirectoryFlag != 0) {
						if (installDirectoryFlag < 0) {
							// Normal directory
							if (path == 0xfffffffe) {
								// Install to current directory
								itemPath << "/" << nameString.String();
								directoryCount++;
							} else if (path == 0xffffffff) {
								// Install to install directory
								pathType = P_INSTALL_PATH;
								itemPath = installDirectory;
								itemPath << nameString;
								directoryCount = 1;
							} else {
								// Install to defined directory
								if (cust) {
									BString *def = static_cast<BString *>(
										userPaths.ItemAt(path));
									if (!def) {
										RETURN_AND_SET_STATUS(B_ERROR);
									}
									if ((*def)[0] == '/')
										pathType = P_SYSTEM_PATH;
									else
										pathType = P_USER_PATH;

									itemPath = *def;
								} else {
									BPath *def = static_cast<BPath *>(
										systemPaths.ItemAt(path));
									if (!def) {
										RETURN_AND_SET_STATUS(B_ERROR);
									}
									pathType = P_SYSTEM_PATH;

									itemPath = def->Path();
								}

								itemPath << "/" << nameString;
								directoryCount = 1;
							}
						} else {
							// Install directory
							if (path != 0xffffffff) {
								RETURN_AND_SET_STATUS(B_ERROR);
							}

							installDirectory = nameString;
							installDirectory << "/";
							pathType = P_INSTALL_PATH;
							itemPath = nameString;

							installDirectoryFlag = -1;
						}

						parser_debug("Adding the directory %s!\n",
							itemPath.String());

						item = new PackageDirectory(fPackageFile, itemPath,
							pathType, ctime, mtime, offset, size);
					} else
						installDirectoryFlag = -1;
				}
			} else if (element == P_LINK) {
				if (itemGroups && linkString.Length()) {
					BString dest = "";
					uint8 localType = pathType;

					if (path == 0xfffffffe)
						dest << itemPath << "/" << nameString.String();
					else if (path == 0xffffffff) {
						localType = P_INSTALL_PATH;
						dest = installDirectory;
						dest << nameString;
					} else {
						if (cust) {
							BString *def = static_cast<BString *>(
								userPaths.ItemAt(path));
							if (!def) {
								RETURN_AND_SET_STATUS(B_ERROR);
							}
							if ((*def)[0] == '/')
								localType = P_SYSTEM_PATH;
							else
								localType = P_USER_PATH;

							dest << *def << "/" << nameString;
						} else {
							BPath *def = static_cast<BPath *>(systemPaths.ItemAt(path));
							if (!def) {
								RETURN_AND_SET_STATUS(B_ERROR);
							}
							localType = P_SYSTEM_PATH;

							dest << def->Path() << "/" << nameString;
						}
					}

					parser_debug("Adding link: %s! (type %s)\n", dest.String(),
						pathType == P_SYSTEM_PATH
							? "System" : localType == P_INSTALL_PATH
							? "Install" : "User");

					item = new PackageLink(fPackageFile, dest, linkString,
						localType, ctime, mtime, mode, offset, size);
				}
			} else if (element == P_SCRIPT) {
				parser_debug("Adding the script %s!\n",
					nameString.String());

				BString workingDirectory;
				uint8 localType = P_SYSTEM_PATH;
				if (path == 1)
					workingDirectory << itemPath;
				else if (path == 0xffffffff) {
					workingDirectory << installDirectory;
					localType = P_INSTALL_PATH;
				}

				fScripts.AddItem(new PackageScript(fPackageFile,
					workingDirectory, localType, offset, size, originalSize));
			} else {
				// If the directory tree count is equal to zero, this means all
				// directory trees have been closed and a padding sequence means the
				// end of the section
				if (directoryCount == 0)
					break;
				ret = itemPath.FindLast('/');
				if (ret == B_ERROR) {
					itemPath = "";
				}
				else {
					itemPath.Truncate(ret);
				}
				directoryCount--;
			}

			if (item) {
				_AddItem(item, originalSize, itemGroups, path, cust);
			}

			element = P_NONE;
		} else if (!memcmp(buffer, "PkgA", 5)) {
			parser_debug("PkgA\n");
			break;
		} else if (!memcmp(buffer, "PtcI", 5)) {
			parser_debug("PtcI\n");
			break;
		} else {
			fprintf(stderr, "Unknown file tag %s\n", buffer);
			RETURN_AND_SET_STATUS(B_ERROR);
		}
	}

	if (static_cast<uint64>(actualSize) != fileSize) {
		// Inform the user of a possible error
		int32 selection;
		BAlert *warning = new BAlert("filesize_wrong",
			B_TRANSLATE("There seems to be a file size mismatch in the "
				"package file. The package might be corrupted or have been "
				"modified after its creation. Do you still wish to continue?"),
				B_TRANSLATE("Continue"),
				B_TRANSLATE("Abort"), NULL,
			B_WIDTH_AS_USUAL, B_WARNING_ALERT);
		warning->SetShortcut(1, B_ESCAPE);
		selection = warning->Go();

		if (selection == 1) {
			RETURN_AND_SET_STATUS(B_ERROR);
		}
	}

	if (!groups.IsEmpty())
		fProfiles = groups;

	return B_OK;
}


void
PackageInfo::_AddItem(PackageItem *item, uint64 size, uint32 groups,
	uint32 path, uint32 cust)
{
	// Add the item to all groups it resides in
	uint32 i, n = fProfiles.CountItems(), mask = 1;
	pkg_profile *profile;

	fFiles.AddItem(item);

	for (i = 0;i < n;i++) {
		if (groups & mask) {
			profile = static_cast<pkg_profile *>(fProfiles.ItemAt(i));
			profile->items.AddItem(item);
			profile->space_needed += size;
			// If there is at least one non-predefined destination element
			// in the package, we give the user the ability to select the
			// installation directory.
			// If there are only predefined path files in the package, but
			// such defined by the user, the user will be able to select
			// the destination volume
			if (path == 0xffffffff)
				profile->path_type = P_INSTALL_PATH;
			else if (path < 0xfffffffe &&
					profile->path_type != P_INSTALL_PATH) {
				if (cust) {
					profile->path_type = P_USER_PATH;
				}
			}
		}
		mask = mask << 1;
	}
}