haiku.git

/*
 * Copyright 2011-2020, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Oliver Tappe <zooey@hirschkaefer.de>
 *		Andrew Lindesay <apl@lindesay.co.nz>
 */


#include <package/RepositoryInfo.h>

#include <stdlib.h>

#include <new>

#include <driver_settings.h>
#include <File.h>
#include <Message.h>

#include <AutoDeleter.h>
#include <AutoDeleterDrivers.h>
#include <package/PackageInfo.h>


namespace BPackageKit {


const uint8 BRepositoryInfo::kDefaultPriority	= 50;

const char* const BRepositoryInfo::kNameField			= "name";
const char* const BRepositoryInfo::kURLField			= "url";
const char* const BRepositoryInfo::kIdentifierField		= "identifier";
const char* const BRepositoryInfo::kBaseURLField		= "baseUrl";
const char* const BRepositoryInfo::kVendorField			= "vendor";
const char* const BRepositoryInfo::kSummaryField		= "summary";
const char* const BRepositoryInfo::kPriorityField		= "priority";
const char* const BRepositoryInfo::kArchitectureField	= "architecture";
const char* const BRepositoryInfo::kLicenseNameField	= "licenseName";
const char* const BRepositoryInfo::kLicenseTextField	= "licenseText";


BRepositoryInfo::BRepositoryInfo()
	:
	fInitStatus(B_NO_INIT),
	fPriority(kDefaultPriority),
	fArchitecture(B_PACKAGE_ARCHITECTURE_ENUM_COUNT)
{
}


BRepositoryInfo::BRepositoryInfo(BMessage* data)
	:
	inherited(data),
	fLicenseTexts(5)
{
	fInitStatus = _SetTo(data);
}


BRepositoryInfo::BRepositoryInfo(const BEntry& entry)
{
	fInitStatus = _SetTo(entry);
}


BRepositoryInfo::~BRepositoryInfo()
{
}


/*static*/ BRepositoryInfo*
BRepositoryInfo::Instantiate(BMessage* data)
{
	if (validate_instantiation(data, "BPackageKit::BRepositoryInfo"))
		return new (std::nothrow) BRepositoryInfo(data);

	return NULL;
}


status_t
BRepositoryInfo::Archive(BMessage* data, bool deep) const
{
	status_t result = inherited::Archive(data, deep);
	if (result != B_OK)
		return result;

	if (!fBaseURL.IsEmpty()) {
		if ((result = data->AddString(kBaseURLField, fBaseURL)) != B_OK)
			return result;
	}

	if ((result = data->AddString(kNameField, fName)) != B_OK)
		return result;
	if ((result = data->AddString(kIdentifierField, fIdentifier)) != B_OK)
		return result;
	// "url" is an older, deprecated key for "identifier"
	if ((result = data->AddString(kURLField, fIdentifier)) != B_OK)
		return result;
	if ((result = data->AddString(kVendorField, fVendor)) != B_OK)
		return result;
	if ((result = data->AddString(kSummaryField, fSummary)) != B_OK)
		return result;
	if ((result = data->AddUInt8(kPriorityField, fPriority)) != B_OK)
		return result;
	if ((result = data->AddUInt8(kArchitectureField, fArchitecture)) != B_OK)
		return result;
	for (int i = 0; i < fLicenseNames.CountStrings(); ++i) {
		result = data->AddString(kLicenseNameField, fLicenseNames.StringAt(i));
		if (result != B_OK)
			return result;
	}
	for (int i = 0; i < fLicenseTexts.CountStrings(); ++i) {
		result = data->AddString(kLicenseTextField, fLicenseTexts.StringAt(i));
		if (result != B_OK)
			return result;
	}

	return B_OK;
}


status_t
BRepositoryInfo::InitCheck() const
{
	return fInitStatus;
}


status_t
BRepositoryInfo::SetTo(const BMessage* data)
{
	return fInitStatus = _SetTo(data);
}


status_t
BRepositoryInfo::SetTo(const BEntry& entry)
{
	return fInitStatus = _SetTo(entry);
}


const BString&
BRepositoryInfo::Name() const
{
	return fName;
}


const BString&
BRepositoryInfo::BaseURL() const
{
	return fBaseURL;
}


const BString&
BRepositoryInfo::Identifier() const
{
	return fIdentifier;
}


const BString&
BRepositoryInfo::Vendor() const
{
	return fVendor;
}


const BString&
BRepositoryInfo::Summary() const
{
	return fSummary;
}


uint8
BRepositoryInfo::Priority() const
{
	return fPriority;
}


BPackageArchitecture
BRepositoryInfo::Architecture() const
{
	return fArchitecture;
}


const BStringList&
BRepositoryInfo::LicenseNames() const
{
	return fLicenseNames;
}


const BStringList&
BRepositoryInfo::LicenseTexts() const
{
	return fLicenseTexts;
}


void
BRepositoryInfo::SetName(const BString& name)
{
	fName = name;
}


void
BRepositoryInfo::SetIdentifier(const BString& identifier)
{
	fIdentifier = identifier;
}


void
BRepositoryInfo::SetBaseURL(const BString& url)
{
	fBaseURL = url;
}


void
BRepositoryInfo::SetVendor(const BString& vendor)
{
	fVendor = vendor;
}


void
BRepositoryInfo::SetSummary(const BString& summary)
{
	fSummary = summary;
}


void
BRepositoryInfo::SetPriority(uint8 priority)
{
	fPriority = priority;
}


void
BRepositoryInfo::SetArchitecture(BPackageArchitecture architecture)
{
	fArchitecture = architecture;
}


status_t
BRepositoryInfo::AddLicense(const BString& licenseName,
	const BString& licenseText)
{
	if (!fLicenseNames.Add(licenseName) || !fLicenseTexts.Add(licenseText))
		return B_NO_MEMORY;

	return B_OK;
}


void
BRepositoryInfo::ClearLicenses()
{
	fLicenseNames.MakeEmpty();
	fLicenseTexts.MakeEmpty();
}


status_t
BRepositoryInfo::_SetTo(const BMessage* data)
{
	if (data == NULL)
		return B_BAD_VALUE;

	status_t result;
	if ((result = data->FindString(kNameField, &fName)) != B_OK)
		return result;
	result = data->FindString(kIdentifierField, &fIdentifier);
	if (result == B_NAME_NOT_FOUND) {
		result = data->FindString(kURLField, &fIdentifier);
			// this is a legacy key for the identifier.
	}
	if (result != B_OK)
		return result;
	if ((result = data->FindString(kVendorField, &fVendor)) != B_OK)
		return result;
	if ((result = data->FindString(kSummaryField, &fSummary)) != B_OK)
		return result;
	if ((result = data->FindUInt8(kPriorityField, &fPriority)) != B_OK)
		return result;
	if ((result = data->FindUInt8(
			kArchitectureField, (uint8*)&fArchitecture)) != B_OK) {
		return result;
	}
	if (fArchitecture == B_PACKAGE_ARCHITECTURE_ANY)
		return B_BAD_DATA;

	// this field is optional because earlier versions did not support this
	// field.
	status_t baseUrlResult = data->FindString(kBaseURLField, &fBaseURL);
	switch (baseUrlResult) {
		case B_NAME_NOT_FOUND:
			// This is a temporary measure because older versions of the file
			// format would take the "url" (identifier) field for the "base-url"
			// Once this transitional period is over this can be removed.
			if (fIdentifier.StartsWith("http"))
				fBaseURL = fIdentifier;
			break;
		case B_OK:
			break;
		default:
			return baseUrlResult;
	}

	const char* licenseName;
	const char* licenseText;
	for (int i = 0;
		data->FindString(kLicenseNameField, i, &licenseName) == B_OK
			&& data->FindString(kLicenseTextField, i, &licenseText) == B_OK;
		++i) {
		if (!fLicenseNames.Add(licenseName) || !fLicenseTexts.Add(licenseText))
			return B_NO_MEMORY;
	}

	return B_OK;
}


status_t
BRepositoryInfo::_SetTo(const BEntry& entry)
{
	BFile file(&entry, B_READ_ONLY);
	status_t result = file.InitCheck();
	if (result != B_OK)
		return result;

	off_t size;
	if ((result = file.GetSize(&size)) != B_OK)
		return result;

	BString configString;
	char* buffer = configString.LockBuffer(size);
	if (buffer == NULL)
		return B_NO_MEMORY;

	if ((result = file.Read(buffer, size)) < size) {
		configString.UnlockBuffer(0);
		return (result >= 0) ? B_IO_ERROR : result;
	}

	buffer[size] = '\0';
	configString.UnlockBuffer(size);

	DriverSettingsUnloader settingsHandle(
		parse_driver_settings_string(configString.String()));
	if (!settingsHandle.IsSet())
		return B_BAD_DATA;

	const char* name = get_driver_parameter(settingsHandle.Get(), "name", NULL,
		NULL);
	const char* identifier = get_driver_parameter(settingsHandle.Get(),
		"identifier", NULL, NULL);
	// Also handle the old name if the new one isn't found
	if (identifier == NULL || *identifier == '\0')
		identifier = get_driver_parameter(settingsHandle.Get(),
			"url", NULL, NULL);
	const char* baseUrl = get_driver_parameter(settingsHandle.Get(),
		"baseurl", NULL, NULL);
	const char* vendor = get_driver_parameter(settingsHandle.Get(),
		"vendor", NULL, NULL);
	const char* summary = get_driver_parameter(settingsHandle.Get(),
		"summary", NULL, NULL);
	const char* priorityString = get_driver_parameter(settingsHandle.Get(),
		"priority", NULL, NULL);
	const char* architectureString = get_driver_parameter(settingsHandle.Get(),
		"architecture", NULL, NULL);

	if (name == NULL || *name == '\0'
		|| identifier == NULL || *identifier == '\0'
		|| vendor == NULL || *vendor == '\0'
		|| summary == NULL || *summary == '\0'
		|| priorityString == NULL || *priorityString == '\0'
		|| architectureString == NULL || *architectureString == '\0') {
		return B_BAD_DATA;
	}

	BPackageArchitecture architecture;
	if (BPackageInfo::GetArchitectureByName(architectureString, architecture)
			!= B_OK || architecture == B_PACKAGE_ARCHITECTURE_ANY) {
		return B_BAD_DATA;
	}

	fName = name;
	fBaseURL = baseUrl;
	fIdentifier = identifier;
	fVendor = vendor;
	fSummary = summary;
	fPriority = atoi(priorityString);
	fArchitecture = architecture;

	return B_OK;
}


}	// namespace BPackageKit