haiku.git

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


#include "UnpackingLeafNode.h"

#include <string.h>

#include <algorithm>
#include <new>

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


CLASS_CACHE(UnpackingLeafNode);


UnpackingLeafNode::UnpackingLeafNode(ino_t id)
	:
	Node(id),
	fFinalPackageNode(NULL)
{
}


UnpackingLeafNode::~UnpackingLeafNode()
{
	if (fFinalPackageNode != NULL)
		fFinalPackageNode->ReleaseReference();
}


status_t
UnpackingLeafNode::VFSInit(dev_t deviceID)
{
	status_t error = NodeInitVFS(deviceID, fID, _ActivePackageNode());
	if (error == B_OK)
		Node::VFSInit(deviceID);

	return error;
}


void
UnpackingLeafNode::VFSUninit()
{
	NodeUninitVFS(_ActivePackageNode(), fFlags);
	Node::VFSUninit();
}


mode_t
UnpackingLeafNode::Mode() const
{
	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->Mode();
	return S_IFREG | S_IRUSR | S_IRGRP | S_IROTH;
}


uid_t
UnpackingLeafNode::UserID() const
{
	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->UserID();
	return 0;
}


gid_t
UnpackingLeafNode::GroupID() const
{
	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->GroupID();
	return 0;
}


timespec
UnpackingLeafNode::ModifiedTime() const
{
	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->ModifiedTime();

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


off_t
UnpackingLeafNode::FileSize() const
{
	if (PackageLeafNode* packageNode = _ActivePackageNode()) {
		if (S_ISLNK(packageNode->Mode()))
			return strlen(packageNode->SymlinkPath());
		return packageNode->FileSize();
	}
	return 0;
}


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


status_t
UnpackingLeafNode::AddPackageNode(PackageNode* packageNode, dev_t deviceID)
{
	ASSERT(fFinalPackageNode == NULL);

	if (S_ISDIR(packageNode->Mode()))
		return B_IS_A_DIRECTORY;

	PackageLeafNode* packageLeafNode
		= dynamic_cast<PackageLeafNode*>(packageNode);

	PackageLeafNode* headNode = fPackageNodes.Head();
	bool overridesHead = headNode == NULL
		|| packageLeafNode->HasPrecedenceOver(headNode);

	if (overridesHead) {
		fPackageNodes.Add(packageLeafNode);
		NodeReinitVFS(deviceID, fID, packageLeafNode, headNode, fFlags);
	} else {
		// add after the head
		fPackageNodes.RemoveHead();
		fPackageNodes.Add(packageLeafNode);
		fPackageNodes.Add(headNode);
	}

	return B_OK;
}


void
UnpackingLeafNode::RemovePackageNode(PackageNode* packageNode, dev_t deviceID)
{
	ASSERT(fFinalPackageNode == NULL);

	bool isNewest = packageNode == fPackageNodes.Head();
	fPackageNodes.Remove(dynamic_cast<PackageLeafNode*>(packageNode));

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

		// re-add the newest node to the head
		fPackageNodes.Remove(newestNode);
		fPackageNodes.Add(newestNode);
		NodeReinitVFS(deviceID, fID, newestNode, packageNode, fFlags);
	}
}


PackageNode*
UnpackingLeafNode::GetPackageNode()
{
	return _ActivePackageNode();
}


bool
UnpackingLeafNode::IsOnlyPackageNode(PackageNode* node) const
{
	ASSERT(fFinalPackageNode == NULL);

	PackageLeafNode* head = fPackageNodes.Head();
	return node == head && fPackageNodes.GetNext(head) == NULL;
}


bool
UnpackingLeafNode::WillBeFirstPackageNode(PackageNode* packageNode) const
{
	PackageLeafNode* packageLeafNode
		= dynamic_cast<PackageLeafNode*>(packageNode);
	if (packageLeafNode == NULL)
		return false;

	PackageLeafNode* headNode = fPackageNodes.Head();
	return headNode == NULL
		|| packageLeafNode->HasPrecedenceOver(headNode);
}

void
UnpackingLeafNode::PrepareForRemoval()
{
	ASSERT(fFinalPackageNode == NULL);

	fFinalPackageNode = fPackageNodes.Head();
	if (fFinalPackageNode != NULL) {
		fFinalPackageNode->AcquireReference();
		fPackageNodes.MakeEmpty();
	}
}


status_t
UnpackingLeafNode::CloneTransferPackageNodes(ino_t id, UnpackingNode*& _newNode)
{
	ASSERT(fFinalPackageNode == NULL);

	UnpackingLeafNode* clone = new UnpackingLeafNode(id);
	if (clone == NULL)
		return B_NO_MEMORY;

	status_t error = clone->Init(Name());
	if (error != B_OK) {
		delete clone;
		return error;
	}

	// We keep the old head as fFinalPackageNode, which will make us to behave
	// exactly as before with respect to FS operations.
	fFinalPackageNode = fPackageNodes.Head();
	if (fFinalPackageNode != NULL) {
		fFinalPackageNode->AcquireReference();
		clone->fPackageNodes.TakeFrom(&fPackageNodes);
	}

	_newNode = clone;
	return B_OK;
}


status_t
UnpackingLeafNode::Read(off_t offset, void* buffer, size_t* bufferSize)
{
	if (HasVFSInitError())
		return B_ERROR;

	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->Read(offset, buffer, bufferSize);
	return B_ERROR;
}


status_t
UnpackingLeafNode::Read(io_request* request)
{
	if (HasVFSInitError())
		return B_ERROR;

	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->Read(request);
	return EBADF;
}


status_t
UnpackingLeafNode::ReadSymlink(void* buffer, size_t* bufferSize)
{
	if (HasVFSInitError())
		return B_ERROR;

	PackageLeafNode* packageNode = _ActivePackageNode();
	if (packageNode == NULL)
		return B_BAD_VALUE;

	const String& linkPath = packageNode->SymlinkPath();
	if (linkPath[0] == '\0') {
		*bufferSize = 0;
		return B_OK;
	}

	size_t linkLength = strnlen(linkPath, B_PATH_NAME_LENGTH);

	size_t bytesToCopy = std::min(linkLength, *bufferSize);

	*bufferSize = linkLength;

	memcpy(buffer, linkPath, bytesToCopy);
	return B_OK;
}


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

	return UnpackingAttributeDirectoryCookie::Open(_ActivePackageNode(),
		_cookie);
}


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

	return UnpackingAttributeCookie::Open(_ActivePackageNode(), name, openMode,
		_cookie);
}


status_t
UnpackingLeafNode::IndexAttribute(AttributeIndexer* indexer)
{
	return UnpackingAttributeCookie::IndexAttribute(_ActivePackageNode(),
		indexer);
}


void*
UnpackingLeafNode::IndexCookieForAttribute(const StringKey& name) const
{
	if (PackageLeafNode* packageNode = _ActivePackageNode())
		return packageNode->IndexCookieForAttribute(name);
	return NULL;
}


PackageLeafNode*
UnpackingLeafNode::_ActivePackageNode() const
{
	if (PackageLeafNode* packageNode = fPackageNodes.Head())
		return packageNode;
	return fFinalPackageNode;
}