haiku.git

/*
 * Copyright 2003-2013, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "Directory.h"
#include "File.h"
#include "Link.h"

#include <StorageDefs.h>
#include <KernelExport.h>

#include <string.h>
#include <unistd.h>


// temp. private VFS API
extern Node *get_node_from(int fd);


using std::nothrow;


namespace BFS {


Directory::Directory(Volume &volume, block_run run)
	:
	fStream(volume, run),
	fTree(&fStream)
{
}


Directory::Directory(Volume &volume, off_t id)
	:
	fStream(volume, id),
	fTree(&fStream)
{
}


Directory::Directory(const Stream &stream)
	:
	fStream(stream),
	fTree(&fStream)
{
}


Directory::~Directory()
{
}


status_t
Directory::InitCheck()
{
	return fStream.InitCheck();
}


status_t
Directory::Open(void **_cookie, int mode)
{
	_inherited::Open(_cookie, mode);

	*_cookie = (void *)new(nothrow) TreeIterator(&fTree);
	if (*_cookie == NULL)
		return B_NO_MEMORY;

	return B_OK;
}


status_t
Directory::Close(void *cookie)
{
	_inherited::Close(cookie);

	delete (TreeIterator *)cookie;
	return B_OK;
}


Node*
Directory::LookupDontTraverse(const char* name)
{
	off_t id;
	if (fTree.Find((uint8 *)name, strlen(name), &id) < B_OK)
		return NULL;

	return Stream::NodeFactory(fStream.GetVolume(), id);
}


status_t
Directory::GetNextEntry(void *cookie, char *name, size_t size)
{
	TreeIterator *iterator = (TreeIterator *)cookie;
	uint16 length;
	off_t id;

	return iterator->GetNextEntry(name, &length, size, &id);
}


status_t
Directory::GetNextNode(void *cookie, Node **_node)
{
	TreeIterator *iterator = (TreeIterator *)cookie;
	char name[B_FILE_NAME_LENGTH];
	uint16 length;
	off_t id;

	status_t status = iterator->GetNextEntry(name, &length, sizeof(name), &id);
	if (status != B_OK)
		return status;

	*_node = Stream::NodeFactory(fStream.GetVolume(), id);
	if (*_node == NULL)
		return B_ERROR;

	return B_OK;
}


status_t
Directory::Rewind(void *cookie)
{
	TreeIterator *iterator = (TreeIterator *)cookie;

	return iterator->Rewind();
}


bool
Directory::IsEmpty()
{
	TreeIterator iterator(&fTree);

	// index and attribute directories are really empty when they are
	// empty - directories for standard files always contain ".", and
	// "..", so we need to ignore those two

	uint32 count = 0;
	char name[BPLUSTREE_MAX_KEY_LENGTH];
	uint16 length;
	off_t id;
	while (iterator.GetNextEntry(name, &length, B_FILE_NAME_LENGTH, &id)
			== B_OK) {
		if (fStream.Mode() & (S_ATTR_DIR | S_INDEX_DIR))
			return false;

		if (++count > 2 || (strcmp(".", name) && strcmp("..", name)))
			return false;
	}
	return true;
}


status_t
Directory::GetName(char *name, size_t size) const
{
	if (fStream.inode_num == fStream.GetVolume().Root()) {
		strlcpy(name, fStream.GetVolume().SuperBlock().name, size);
		return B_OK;
	}

	return fStream.GetName(name, size);
}


ino_t
Directory::Inode() const
{
	return fStream.ID();
}


}	// namespace BFS