/*
* 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;
}
}
↑ V773 The function was exited without releasing the 'warning' pointer. A memory leak is possible.