haiku.git

/*
 * Copyright 2009-2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "UnpackingDirectory.h"

#include "ClassCache.h"
#include "DebugSupport.h"
#include "EmptyAttributeDirectoryCookie.h"
#include "UnpackingAttributeCookie.h"
#include "UnpackingAttributeDirectoryCookie.h"
#include "Utils.h"


// #pragma mark - UnpackingDirectory


CLASS_CACHE(UnpackingDirectory);


UnpackingDirectory::UnpackingDirectory(ino_t id)
	:
	Directory(id)
{
}


UnpackingDirectory::~UnpackingDirectory()
{
}


status_t
UnpackingDirectory::VFSInit(dev_t deviceID)
{
	status_t error = NodeInitVFS(deviceID, fID, fPackageDirectories.Head());
	if (error == B_OK)
		Directory::VFSInit(deviceID);

	return error;
}


void
UnpackingDirectory::VFSUninit()
{
	NodeUninitVFS(fPackageDirectories.Head(), fFlags);
	Directory::VFSUninit();
}


mode_t
UnpackingDirectory::Mode() const
{
	if (PackageDirectory* packageDirectory = fPackageDirectories.Head())
		return packageDirectory->Mode();
	return S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
}


uid_t
UnpackingDirectory::UserID() const
{
	if (PackageDirectory* packageDirectory = fPackageDirectories.Head())
		return packageDirectory->UserID();
	return 0;
}


gid_t
UnpackingDirectory::GroupID() const
{
	if (PackageDirectory* packageDirectory = fPackageDirectories.Head())
		return packageDirectory->GroupID();
	return 0;
}


timespec
UnpackingDirectory::ModifiedTime() const
{
	if (PackageDirectory* packageDirectory = fPackageDirectories.Head())
		return packageDirectory->ModifiedTime();

	timespec time = { 0, 0 };
	return time;
}


off_t
UnpackingDirectory::FileSize() const
{
	return 0;
}


Node*
UnpackingDirectory::GetNode()
{
	return this;
}


status_t
UnpackingDirectory::AddPackageNode(PackageNode* packageNode, dev_t deviceID)
{
	if (!S_ISDIR(packageNode->Mode()))
		return B_NOT_A_DIRECTORY;

	PackageDirectory* packageDirectory
		= dynamic_cast<PackageDirectory*>(packageNode);

	PackageDirectory* other = fPackageDirectories.Head();
	bool overridesHead = other == NULL
		|| packageDirectory->HasPrecedenceOver(other);

	if (overridesHead) {
		fPackageDirectories.InsertBefore(other, packageDirectory);
		NodeReinitVFS(deviceID, fID, packageDirectory, other, fFlags);
	} else
		fPackageDirectories.Add(packageDirectory);

	return B_OK;
}


void
UnpackingDirectory::RemovePackageNode(PackageNode* packageNode, dev_t deviceID)
{
	bool isNewest = packageNode == fPackageDirectories.Head();
	fPackageDirectories.Remove(dynamic_cast<PackageDirectory*>(packageNode));

	// when removing the newest node, we need to find the next node (the list
	// is not sorted)
	PackageDirectory* newestNode = fPackageDirectories.Head();
	if (isNewest && newestNode != NULL) {
		PackageDirectoryList::Iterator it = fPackageDirectories.GetIterator();
		it.Next();
			// skip the first one
		while (PackageDirectory* otherNode = it.Next()) {
			if (otherNode->HasPrecedenceOver(newestNode))
				newestNode = otherNode;
		}

		fPackageDirectories.Remove(newestNode);
		fPackageDirectories.InsertBefore(fPackageDirectories.Head(), newestNode);
		NodeReinitVFS(deviceID, fID, newestNode, packageNode, fFlags);
	}
}


PackageNode*
UnpackingDirectory::GetPackageNode()
{
	return fPackageDirectories.Head();
}


bool
UnpackingDirectory::IsOnlyPackageNode(PackageNode* node) const
{
	return node == fPackageDirectories.Head()
		&& node == fPackageDirectories.Tail();
}


bool
UnpackingDirectory::WillBeFirstPackageNode(PackageNode* packageNode) const
{
	PackageDirectory* packageDirectory
		= dynamic_cast<PackageDirectory*>(packageNode);
	if (packageDirectory == NULL)
		return false;

	PackageDirectory* other = fPackageDirectories.Head();
	return other == NULL || packageDirectory->HasPrecedenceOver(other);
}


void
UnpackingDirectory::PrepareForRemoval()
{
	fPackageDirectories.MakeEmpty();
}


status_t
UnpackingDirectory::OpenAttributeDirectory(AttributeDirectoryCookie*& _cookie)
{
	if (HasVFSInitError())
		return B_ERROR;

	return UnpackingAttributeDirectoryCookie::Open(fPackageDirectories.Head(),
		_cookie);
}


status_t
UnpackingDirectory::OpenAttribute(const StringKey& name, int openMode,
	AttributeCookie*& _cookie)
{
	if (HasVFSInitError())
		return B_ERROR;

	return UnpackingAttributeCookie::Open(fPackageDirectories.Head(), name,
		openMode, _cookie);
}


status_t
UnpackingDirectory::IndexAttribute(AttributeIndexer* indexer)
{
	return UnpackingAttributeCookie::IndexAttribute(fPackageDirectories.Head(),
		indexer);
}


void*
UnpackingDirectory::IndexCookieForAttribute(const StringKey& name) const
{
	if (PackageDirectory* packageDirectory = fPackageDirectories.Head())
		return packageDirectory->IndexCookieForAttribute(name);
	return NULL;
}


// #pragma mark - RootDirectory


void*
RootDirectory::operator new(size_t size)
{
	return malloc(size);
}


void
RootDirectory::operator delete(void* object)
{
	free(object);
}


RootDirectory::RootDirectory(ino_t id, const timespec& modifiedTime)
	:
	UnpackingDirectory(id),
	fModifiedTime(modifiedTime)
{
}


status_t
RootDirectory::OpenAttributeDirectory(AttributeDirectoryCookie*& _cookie)
{
	if (HasVFSInitError())
		return B_ERROR;

	_cookie = new(std::nothrow) EmptyAttributeDirectoryCookie;
	if (_cookie == nullptr)
		return B_NO_MEMORY;
	return B_OK;
}


timespec
RootDirectory::ModifiedTime() const
{
	return fModifiedTime;
}