storage/mime/DatabaseLocation.cpp

/*
 * Copyright 2002-2014 Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Tyler Dauwalder
 *		Rene Gollent, rene@gollent.com
 *		Ingo Weinhold, ingo_weinhold@gmx.de
 */


#include <mime/DatabaseLocation.h>

#include <stdlib.h>
#include <syslog.h>

#include <new>

#include <Bitmap.h>
#include <DataIO.h>
#include <Directory.h>
#include <File.h>
#include <fs_attr.h>
#include <IconUtils.h>
#include <Message.h>
#include <Node.h>

#include <AutoDeleter.h>
#include <mime/database_support.h>


namespace BPrivate {
namespace Storage {
namespace Mime {


DatabaseLocation::DatabaseLocation()
	:
	fDirectories()
{
}


DatabaseLocation::~DatabaseLocation()
{
}


bool
DatabaseLocation::AddDirectory(const BString& directory)
{
	return !directory.IsEmpty() && fDirectories.Add(directory);
}


/*!	Opens a BNode on the given type, failing if the type has no
	corresponding file in the database.

	\param type The MIME type to open.
	\param _node Node opened on the given MIME type.
*/
status_t
DatabaseLocation::OpenType(const char* type, BNode& _node) const
{
	if (type == NULL)
		return B_BAD_VALUE;

	int32 index;
	return _OpenType(type, _node, index);
}


/*!	Opens a BNode on the given type, creating a node of the
	appropriate flavor if requested (and necessary).

	All MIME types are converted to lowercase for use in the filesystem.

	\param type The MIME type to open.
	\param _node Node opened on the given MIME type.
	\param _didCreate If not \c NULL, the variable the pointer refers to is
	       set to \c true, if the node has been newly created, to \c false
	       otherwise.

	\return A status code.
*/
status_t
DatabaseLocation::OpenWritableType(const char* type, BNode& _node, bool create,
	bool* _didCreate) const
{
	if (_didCreate)
		*_didCreate = false;

	// See, if the type already exists.
	int32 index;
	status_t result = _OpenType(type, _node, index);
	if (result == B_OK) {
		if (index == 0)
			return B_OK;
		else if (!create)
			return B_ENTRY_NOT_FOUND;

		// The caller wants a editable node, but the node found is not in the
		// user's settings directory. Copy the node.
		BNode nodeToClone(_node);
		if (nodeToClone.InitCheck() != B_OK)
			return nodeToClone.InitCheck();

		result = _CopyTypeNode(nodeToClone, type, _node);
		if (result != B_OK) {
			_node.Unset();
			return result;
		}

		if (_didCreate != NULL)
			*_didCreate = true;

		return result;
	} else if (!create)
		return B_ENTRY_NOT_FOUND;

	// type doesn't exist yet -- create the respective node
	result = _CreateTypeNode(type, _node);
	if (result != B_OK)
		return result;

	// write the type attribute
	size_t toWrite = strlen(type) + 1;
	ssize_t bytesWritten = _node.WriteAttr(kTypeAttr, B_STRING_TYPE, 0, type,
		toWrite);
	if (bytesWritten < 0)
		result = bytesWritten;
	else if ((size_t)bytesWritten != toWrite)
		result = B_FILE_ERROR;

	if (result != B_OK) {
		_node.Unset();
		return result;
	}

	if (_didCreate != NULL)
		*_didCreate = true;
	return B_OK;
}


/*! Reads up to \c length bytes of the given data from the given attribute
	for the given MIME type.

	If no entry for the given type exists in the database, the function fails,
	and the contents of \c data are undefined.

	\param type The MIME type.
	\param attribute The attribute name.
	\param data Pointer to a memory buffer into which the data should be copied.
	\param length The maximum number of bytes to read.
	\param datatype The expected data type.

	\return If successful, the number of bytes read is returned, otherwise, an
	        error code is returned.
*/
ssize_t
DatabaseLocation::ReadAttribute(const char* type, const char* attribute,
	void* data, size_t length, type_code datatype) const
{
	if (type == NULL || attribute == NULL || data == NULL)
		return B_BAD_VALUE;

	BNode node;
	status_t result = OpenType(type, node);
	if (result != B_OK)
		return result;

	return node.ReadAttr(attribute, datatype, 0, data, length);
}


/*!	Reads a flattened BMessage from the given attribute of the given
	MIME type.

	If no entry for the given type exists in the database, or if the data
	stored in the attribute is not a flattened BMessage, the function fails
	and the contents of \c msg are undefined.

	\param type The MIME type.
	\param attribute The attribute name.
	\param data Reference to a pre-allocated BMessage into which the attribute
	       data is unflattened.

	\return A status code.
*/
status_t
DatabaseLocation::ReadMessageAttribute(const char* type, const char* attribute,
	BMessage& _message) const
{
	if (type == NULL || attribute == NULL)
		return B_BAD_VALUE;

	BNode node;
	attr_info info;

	status_t result = OpenType(type, node);
	if (result != B_OK)
		return result;

	result = node.GetAttrInfo(attribute, &info);
	if (result != B_OK)
		return result;

	if (info.type != B_MESSAGE_TYPE)
		return B_BAD_VALUE;

	void* buffer = malloc(info.size);
	if (buffer == NULL)
		return B_NO_MEMORY;
	MemoryDeleter bufferDeleter(buffer);

	ssize_t bytesRead = node.ReadAttr(attribute, B_MESSAGE_TYPE, 0, buffer,
		info.size);
	if (bytesRead != info.size)
		return bytesRead < 0 ? (status_t)bytesRead : (status_t)B_FILE_ERROR;

	return _message.Unflatten((const char*)buffer);
}


/*!	Reads a BString from the given attribute of the given MIME type.

	If no entry for the given type exists in the database, the function fails
	and the contents of \c str are undefined.

	\param type The MIME type.
	\param attribute The attribute name.
	\param _string Reference to a pre-allocated BString into which the attribute
	       data stored.

	\return A status code.
*/
status_t
DatabaseLocation::ReadStringAttribute(const char* type, const char* attribute,
	BString& _string) const
{
	if (type == NULL || attribute == NULL)
		return B_BAD_VALUE;

	BNode node;
	status_t result = OpenType(type, node);
	if (result != B_OK)
		return result;

	return node.ReadAttrString(attribute, &_string);
}


/*!	Writes \c len bytes of the given data to the given attribute
	for the given MIME type.

	If no entry for the given type exists in the database, it is created.

	\param type The MIME type.
	\param attribute The attribute name.
	\param data Pointer to the data to write.
	\param length The number of bytes to write.
	\param datatype The data type of the given data.

	\return A status code.
*/
status_t
DatabaseLocation::WriteAttribute(const char* type, const char* attribute,
	const void* data, size_t length, type_code datatype, bool* _didCreate) const
{
	if (type == NULL || attribute == NULL || data == NULL)
		return B_BAD_VALUE;

	BNode node;
	status_t result = OpenWritableType(type, node, true, _didCreate);
	if (result != B_OK)
		return result;

	ssize_t bytesWritten = node.WriteAttr(attribute, datatype, 0, data, length);
	if (bytesWritten < 0)
		return bytesWritten;
	return bytesWritten == (ssize_t)length
		? (status_t)B_OK : (status_t)B_FILE_ERROR;
}


/*! Flattens the given \c BMessage and writes it to the given attribute
	of the given MIME type.

	If no entry for the given type exists in the database, it is created.

	\param type The MIME type.
	\param attribute The attribute name.
	\param message The BMessage to flatten and write.

	\return A status code.
*/
status_t
DatabaseLocation::WriteMessageAttribute(const char* type, const char* attribute,
	const BMessage& message, bool* _didCreate) const
{
	BMallocIO data;
	status_t result = data.SetSize(message.FlattenedSize());
	if (result != B_OK)
		return result;

	ssize_t bytes;
	result = message.Flatten(&data, &bytes);
	if (result != B_OK)
		return result;

	return WriteAttribute(type, attribute, data.Buffer(), data.BufferLength(),
		B_MESSAGE_TYPE, _didCreate);
}


/*!	Deletes the given attribute for the given type

	\param type The mime type
	\param attribute The attribute name

	\return A status code, \c B_OK on success or an error code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No such type or attribute.
*/
status_t
DatabaseLocation::DeleteAttribute(const char* type, const char* attribute) const
{
	if (type == NULL || attribute == NULL)
		return B_BAD_VALUE;

	BNode node;
	status_t result = OpenWritableType(type, node, false);
	if (result != B_OK)
		return result;

	return node.RemoveAttr(attribute);
}


/*! Fetches the application hint for the given MIME type.

	The entry_ref pointed to by \c ref must be pre-allocated.

	\param type The MIME type of interest
	\param _ref Reference to a pre-allocated \c entry_ref struct into
	       which the location of the hint application is copied.

	\return A status code, \c B_OK on success or an error code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No app hint exists for the given type
*/
status_t
DatabaseLocation::GetAppHint(const char* type, entry_ref& _ref)
{
	if (type == NULL)
		return B_BAD_VALUE;

	char path[B_PATH_NAME_LENGTH];
	BEntry entry;
	ssize_t status = ReadAttribute(type, kAppHintAttr, path, B_PATH_NAME_LENGTH,
		kAppHintType);

	if (status >= B_OK)
		status = entry.SetTo(path);
	if (status == B_OK)
		status = entry.GetRef(&_ref);

	return status;
}


/*!	Fetches from the MIME database a BMessage describing the attributes
	typically associated with files of the given MIME type

	The attribute information is returned in a pre-allocated BMessage pointed to
	by the \c info parameter (note that the any prior contents of the message
	will be destroyed). Please see BMimeType::SetAttrInfo() for a description
	of the expected format of such a message.

	\param _info Reference to a pre-allocated BMessage into which information
	       about the MIME type's associated file attributes is stored.

	\return A status code, \c B_OK on success or an error code on failure.
*/
status_t
DatabaseLocation::GetAttributesInfo(const char* type, BMessage& _info)
{
	status_t result = ReadMessageAttribute(type, kAttrInfoAttr, _info);

	if (result == B_ENTRY_NOT_FOUND) {
		// return an empty message
		_info.MakeEmpty();
		result = B_OK;
	}

	if (result == B_OK) {
		_info.what = 233;
			// Don't know why, but that's what R5 does.
		result = _info.AddString("type", type);
	}

	return result;
}


/*!	Fetches the short description for the given MIME type.

	The string pointed to by \c description must be long enough to
	hold the short description; a length of \c B_MIME_TYPE_LENGTH is
	recommended.

	\param type The MIME type of interest
	\param description Pointer to a pre-allocated string into which the short
	       description is copied. If the function fails, the contents of the
	       string are undefined.

	\return A status code, \c B_OK on success or an error code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No short description exists for the given type.
*/
status_t
DatabaseLocation::GetShortDescription(const char* type, char* description)
{
	ssize_t result = ReadAttribute(type, kShortDescriptionAttr, description,
		B_MIME_TYPE_LENGTH, kShortDescriptionType);

	return result >= 0 ? B_OK : result;
}


/*!	Fetches the long description for the given MIME type.

	The string pointed to by \c description must be long enough to
	hold the long description; a length of \c B_MIME_TYPE_LENGTH is
	recommended.

	\param type The MIME type of interest
	\param description Pointer to a pre-allocated string into which the long
	       description is copied. If the function fails, the contents of the
	       string are undefined.

	\return A status code, \c B_OK on success or an error code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No long description exists for the given type
*/
status_t
DatabaseLocation::GetLongDescription(const char* type, char* description)
{
	ssize_t result = ReadAttribute(type, kLongDescriptionAttr, description,
		B_MIME_TYPE_LENGTH, kLongDescriptionType);

	return result >= 0 ? B_OK : result;
}


/*!	Fetches a BMessage describing the MIME type's associated filename
	extensions.

	The list of extensions is returned in a pre-allocated BMessage pointed to
	by the \c extensions parameter (note that the any prior contents of the
	message will be destroyed). Please see BMimeType::GetFileExtensions() for
	a description of the message format.

	\param extensions Reference to a pre-allocated BMessage into which the MIME
	       type's associated file extensions will be stored.

	\return A status code, \c B_OK on success or an error code on failure.
*/
status_t
DatabaseLocation::GetFileExtensions(const char* type, BMessage& _extensions)
{
	status_t result = ReadMessageAttribute(type, kFileExtensionsAttr, _extensions);
	if (result == B_ENTRY_NOT_FOUND) {
		// return an empty message
		_extensions.MakeEmpty();
		result = B_OK;
	}

	if (result == B_OK) {
		_extensions.what = 234;	// Don't know why, but that's what R5 does.
		result = _extensions.AddString("type", type);
	}

	return result;
}


/*!	Fetches the icon of given size associated with the given MIME type.

	The bitmap pointed to by \c icon must be of the proper size (\c 32x32
	for \c B_LARGE_ICON, \c 16x16 for \c B_MINI_ICON) and color depth
	(\c B_CMAP8).

	\param type The mime type
	\param icon Reference to a pre-allocated bitmap of proper dimensions and
	       color depth
	\param size The size icon you're interested in (\c B_LARGE_ICON or
	       \c B_MINI_ICON)

	\return A status code.
*/
status_t
DatabaseLocation::GetIcon(const char* type, BBitmap& _icon, icon_size size)
{
	return GetIconForType(type, NULL, _icon, size);
}


/*!	Fetches the vector icon associated with the given MIME type.

	\param type The mime type
	\param _data Reference via which the allocated icon data is returned. You
	       need to free the buffer once you're done with it.
	\param _size Reference via which the size of the icon data is returned.

	\return A status code.
*/
status_t
DatabaseLocation::GetIcon(const char* type, uint8*& _data, size_t& _size)
{
	return GetIconForType(type, NULL, _data, _size);
}


/*!	Fetches the large or mini icon used by an application of this type
	for files of the given type.

	The type of the \c BMimeType object is not required to actually be a subtype
	of \c "application/"; that is the intended use however, and calling
	\c GetIconForType() on a non-application type will likely return
	\c B_ENTRY_NOT_FOUND.

	The icon is copied into the \c BBitmap pointed to by \c icon. The bitmap
	must be the proper size: \c 32x32 for the large icon, \c 16x16 for the mini
	icon.

	\param type The MIME type
	\param fileType Pointer to a pre-allocated string containing the MIME type
	       whose custom icon you wish to fetch. If NULL, works just like
	       GetIcon().
	\param icon Reference to a pre-allocated \c BBitmap of proper size and
	       colorspace into which the icon is copied.
	\param icon_size Value that specifies which icon to return. Currently
	       \c B_LARGE_ICON and \c B_MINI_ICON are supported.

	\return A status code, \c B_OK on success or an error code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No icon of the given size exists for the given type
*/
status_t
DatabaseLocation::GetIconForType(const char* type, const char* fileType,
	BBitmap& _icon, icon_size which)
{
	if (type == NULL)
		return B_BAD_VALUE;

	// open the node for the given type
	BNode node;
	status_t result = OpenType(type, node);
	if (result != B_OK)
		return result;

	// construct our attribute name
	BString vectorIconAttrName;
	BString smallIconAttrName;
	BString largeIconAttrName;

	if (fileType != NULL) {
		BString lowerCaseFileType(fileType);
		lowerCaseFileType.ToLower();

		vectorIconAttrName << kIconAttrPrefix << lowerCaseFileType;
		smallIconAttrName << kMiniIconAttrPrefix << lowerCaseFileType;
		largeIconAttrName << kLargeIconAttrPrefix << lowerCaseFileType;
	} else {
		vectorIconAttrName = kIconAttr;
		smallIconAttrName = kMiniIconAttr;
		largeIconAttrName = kLargeIconAttr;
	}

	return BIconUtils::GetIcon(&node, vectorIconAttrName, smallIconAttrName,
		largeIconAttrName, which, &_icon);
}


/*!	Fetches the vector icon used by an application of this type for files
	of the given type.

	The type of the \c BMimeType object is not required to actually be a subtype
	of \c "application/"; that is the intended use however, and calling
	\c GetIconForType() on a non-application type will likely return
	\c B_ENTRY_NOT_FOUND.

	The icon data is allocated and returned in \a _data.

	\param type The MIME type
	\param fileType Reference to a pre-allocated string containing the MIME type
	       whose custom icon you wish to fetch. If NULL, works just like
	       GetIcon().
	\param _data Reference via which the icon data is returned on success.
	\param _size Reference via which the size of the icon data is returned.

	\return A status code, \c B_OK on success or another code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No vector icon existed for the given type.
*/
status_t
DatabaseLocation::GetIconForType(const char* type, const char* fileType,
	uint8*& _data, size_t& _size)
{
	if (type == NULL)
		return B_BAD_VALUE;

	// open the node for the given type
	BNode node;
	status_t result = OpenType(type, node);
	if (result != B_OK)
		return result;

	// construct our attribute name
	BString iconAttrName;

	if (fileType != NULL)
		iconAttrName << kIconAttrPrefix << BString(fileType).ToLower();
	else
		iconAttrName = kIconAttr;

	// get info about attribute for that name
	attr_info info;
	if (result == B_OK)
		result = node.GetAttrInfo(iconAttrName, &info);

	// validate attribute type
	if (result == B_OK)
		result = (info.type == B_VECTOR_ICON_TYPE) ? B_OK : B_BAD_VALUE;

	// allocate a buffer and read the attribute data into it
	if (result == B_OK) {
		uint8* buffer = new(std::nothrow) uint8[info.size];
		if (buffer == NULL)
			result = B_NO_MEMORY;

		ssize_t bytesRead = -1;
		if (result == B_OK) {
			bytesRead = node.ReadAttr(iconAttrName, B_VECTOR_ICON_TYPE, 0, buffer,
				info.size);
		}

		if (bytesRead >= 0)
			result = bytesRead == info.size ? B_OK : B_FILE_ERROR;

		if (result == B_OK) {
			// success, set data pointer and size
			_data = buffer;
			_size = info.size;
		} else
			delete[] buffer;
	}

	return result;
}


/*!	Fetches signature of the MIME type's preferred application for the
	given action.

	The string pointed to by \c signature must be long enough to
	hold the short description; a length of \c B_MIME_TYPE_LENGTH is
	recommended.

	Currently, the only supported app verb is \c B_OPEN.

	\param type The MIME type of interest
	\param description Pointer to a pre-allocated string into which the
	       preferred application's signature is copied. If the function fails,
	       the contents of the string are undefined.
	\param verb \c The action of interest

	\return A status code, \c B_OK on success or another code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No such preferred application exists
*/
status_t
DatabaseLocation::GetPreferredApp(const char* type, char* signature,
	app_verb verb)
{
	// Since B_OPEN is the currently the only app_verb, it is essentially
	// ignored
	ssize_t result = ReadAttribute(type, kPreferredAppAttr, signature,
		B_MIME_TYPE_LENGTH, kPreferredAppType);

	return result >= 0 ? B_OK : result;
}


/*!	Fetches the sniffer rule for the given MIME type.
	\param type The MIME type of interest
	\param _result Pointer to a pre-allocated BString into which the type's
	       sniffer rule is copied.

	\return A status code, \c B_OK on success or another code on failure.
	\retval B_OK Success.
	\retval B_ENTRY_NOT_FOUND No such preferred application exists.
*/
status_t
DatabaseLocation::GetSnifferRule(const char* type, BString& _result)
{
	return ReadStringAttribute(type, kSnifferRuleAttr, _result);
}


status_t
DatabaseLocation::GetSupportedTypes(const char* type, BMessage& _types)
{
	status_t result = ReadMessageAttribute(type, kSupportedTypesAttr, _types);
	if (result == B_ENTRY_NOT_FOUND) {
		// return an empty message
		_types.MakeEmpty();
		result = B_OK;
	}
	if (result == B_OK) {
		_types.what = 0;
		result = _types.AddString("type", type);
	}

	return result;
}


//! Checks if the given MIME type is present in the database
bool
DatabaseLocation::IsInstalled(const char* type)
{
	BNode node;
	return OpenType(type, node) == B_OK;
}


BString
DatabaseLocation::_TypeToFilename(const char* type, int32 index) const
{
	BString path = fDirectories.StringAt(index);
	return path << '/' << BString(type).ToLower();
}


status_t
DatabaseLocation::_OpenType(const char* type, BNode& _node, int32& _index) const
{
	int32 count = fDirectories.CountStrings();
	for (int32 i = 0; i < count; i++) {
		status_t result = _node.SetTo(_TypeToFilename(type, i));
		attr_info attrInfo;
		if (result == B_OK && _node.GetAttrInfo(kTypeAttr, &attrInfo) == B_OK) {
			_index = i;
			return B_OK;
		}
	}

	return B_ENTRY_NOT_FOUND;
}


status_t
DatabaseLocation::_CreateTypeNode(const char* type, BNode& _node) const
{
	const char* slash = strchr(type, '/');
	BString superTypeName;
	if (slash != NULL)
		superTypeName.SetTo(type, slash - type);
	else
		superTypeName = type;
	superTypeName.ToLower();

	// open/create the directory for the supertype
	BDirectory parent(WritableDirectory());
	status_t result = parent.InitCheck();
	if (result != B_OK)
		return result;

	BDirectory superTypeDirectory;
	if (BEntry(&parent, superTypeName).Exists())
		result = superTypeDirectory.SetTo(&parent, superTypeName);
	else
		result = parent.CreateDirectory(superTypeName, &superTypeDirectory);

	if (result != B_OK)
		return result;

	// create the subtype
	BFile subTypeFile;
	if (slash != NULL) {
		result = superTypeDirectory.CreateFile(BString(slash + 1).ToLower(),
			&subTypeFile);
		if (result != B_OK)
			return result;
	}

	// assign the result
	if (slash != NULL)
		_node = subTypeFile;
	else
		_node = superTypeDirectory;
	return _node.InitCheck();
}


status_t
DatabaseLocation::_CopyTypeNode(BNode& source, const char* type, BNode& _target)
	const
{
	status_t result = _CreateTypeNode(type, _target);
	if (result != B_OK)
		return result;

	// copy the attributes
	MemoryDeleter bufferDeleter;
	size_t bufferSize = 0;

	source.RewindAttrs();
	char attribute[B_ATTR_NAME_LENGTH];
	while (source.GetNextAttrName(attribute) == B_OK) {
		attr_info info;
		result = source.GetAttrInfo(attribute, &info);
		if (result != B_OK) {
			syslog(LOG_ERR, "Failed to get info for attribute \"%s\" of MIME "
				"type \"%s\": %s", attribute, type, strerror(result));
			continue;
		}

		// resize our buffer, if necessary
		if (info.size > (off_t)bufferSize) {
			bufferDeleter.SetTo(malloc(info.size));
			if (!bufferDeleter.IsSet())
				return B_NO_MEMORY;
			bufferSize = info.size;
		}

		ssize_t bytesRead = source.ReadAttr(attribute, info.type, 0,
			bufferDeleter.Get(), info.size);
		if (bytesRead != info.size) {
			syslog(LOG_ERR, "Failed to read attribute \"%s\" of MIME "
				"type \"%s\": %s", attribute, type,
		  		bytesRead < 0 ? strerror(bytesRead) : "short read");
			continue;
		}

		ssize_t bytesWritten = _target.WriteAttr(attribute, info.type, 0,
			bufferDeleter.Get(), info.size);
		if (bytesWritten < 0) {
			syslog(LOG_ERR, "Failed to write attribute \"%s\" of MIME "
				"type \"%s\": %s", attribute, type,
		  		bytesWritten < 0 ? strerror(bytesWritten) : "short write");
			continue;
		}
	}

	return B_OK;
}


} // namespace Mime
} // namespace Storage
} // namespace BPrivate