haiku.git

// NodeHandle.cpp

#include "NodeHandle.h"

#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>

#include <fs_attr.h>

#include "Compatibility.h"
#include "Directory.h"
#include "FDManager.h"
#include "Path.h"

// TODO: Do the FD creation via the FDManager.

// NodeHandle

// constructor
NodeHandle::NodeHandle()
	: BReferenceable(),
	  Lockable(),
	  fCookie(-1),
	  fNodeRef()
{
}

// destructor
NodeHandle::~NodeHandle()
{
}

// GetStat
status_t
NodeHandle::GetStat(struct stat* st)
{
	int fd = GetFD();
	if (fd < 0)
		return B_ENTRY_NOT_FOUND;

	if (fstat(fd, st) < 0)
		return errno;

	return B_OK;
}

// SetCookie
void
NodeHandle::SetCookie(int32 cookie)
{
	fCookie = cookie;
}

// GetCookie
int32
NodeHandle::GetCookie() const
{
	return fCookie;
}

// GetNodeRef
const NodeRef&
NodeHandle::GetNodeRef() const
{
	return fNodeRef;
}

// GetFD
int
NodeHandle::GetFD() const
{
	return -1;
}


// #pragma mark -

// FileHandle

// constructor
FileHandle::FileHandle()
	: fFD(-1)
{
}

// destructor
FileHandle::~FileHandle()
{
	Close();
}

// Open
status_t
FileHandle::Open(Node* node, int openMode)
{
	if (!node)
		return B_BAD_VALUE;

	openMode &= O_RWMASK | O_TRUNC | O_APPEND;

	// get a path
	Path path;
	status_t error = node->GetPath(&path);
	if (error != B_OK)
		return error;

	// open the file
	error = FDManager::Open(path.GetPath(), openMode | O_NOTRAVERSE, 0, fFD);
	if (error != B_OK)
		return error;

	fNodeRef = node->GetNodeRef();

	return B_OK;
}

// Close
status_t
FileHandle::Close()
{
	if (fFD < 0)
		return B_BAD_VALUE;

	status_t error = B_OK;
	if (close(fFD) < 0)
		error = errno;
	fFD = -1;

	return error;
}

// Read
status_t
FileHandle::Read(off_t pos, void* buffer, size_t size, size_t* _bytesRead)
{
	if (fFD < 0)
		return B_BAD_VALUE;

	ssize_t bytesRead = read_pos(fFD, pos, buffer, size);
	if (bytesRead < 0)
		return errno;

	*_bytesRead = bytesRead;
	return B_OK;
}

// Write
status_t
FileHandle::Write(off_t pos, const void* buffer, size_t size,
	size_t* _bytesWritten)
{
	if (fFD < 0)
		return B_BAD_VALUE;

	ssize_t bytesWritten = write_pos(fFD, pos, buffer, size);
	if (bytesWritten < 0)
		return errno;

	*_bytesWritten = bytesWritten;
	return B_OK;
}

// ReadAttr
status_t
FileHandle::ReadAttr(const char* name, uint32 type, off_t pos, void* buffer,
	size_t size, size_t* _bytesRead)
{
	if (fFD < 0)
		return B_BAD_VALUE;

	ssize_t bytesRead = fs_read_attr(fFD, name, type, pos, buffer, size);
	if (bytesRead < 0)
		return errno;

	*_bytesRead = bytesRead;
	return B_OK;
}

// WriteAttr
status_t
FileHandle::WriteAttr(const char* name, uint32 type, off_t pos,
	const void* buffer, size_t size, size_t* _bytesWritten)
{
	if (fFD < 0)
		return B_BAD_VALUE;

	ssize_t bytesWritten = fs_write_attr(fFD, name, type, pos, buffer, size);
	if (bytesWritten < 0)
		return errno;

	*_bytesWritten = bytesWritten;
	return B_OK;
}

// RemoveAttr
status_t
FileHandle::RemoveAttr(const char* name)
{
	if (fFD < 0)
		return B_BAD_VALUE;

	return (fs_remove_attr(fFD, name) == 0 ? B_OK : errno);
}

// StatAttr
status_t
FileHandle::StatAttr(const char* name, attr_info* info)
{
	if (fFD < 0)
		return B_BAD_VALUE;

	return (fs_stat_attr(fFD, name, info) == 0 ? B_OK : errno);
}

// GetFD
int
FileHandle::GetFD() const
{
	return fFD;
}


// #pragma mark -

// DirIterator

// constructor
DirIterator::DirIterator()
	: fDirectory(NULL)
{
}

// destructor
DirIterator::~DirIterator()
{
	if (fDirectory)
		fDirectory->RemoveDirIterator(this);
}

// IsValid
bool
DirIterator::IsValid() const
{
	return fDirectory;
}


// #pragma mark -

// AttrDirIterator

// constructor
AttrDirIterator::AttrDirIterator()
	: NodeHandle(),
	  fDir(NULL)
{
}

// destructor
AttrDirIterator::~AttrDirIterator()
{
	Close();
}

// Open
status_t
AttrDirIterator::Open(Node* node)
{
	if (!node)
		return B_BAD_VALUE;

	// get a path
	Path path;
	status_t error = node->GetPath(&path);
	if (error != B_OK)
		return error;

	// open the attribute directory
	error = FDManager::OpenAttrDir(path.GetPath(), fDir);
	if (error != B_OK)
		return errno;

	fNodeRef = node->GetNodeRef();

	return B_OK;
}

// Close
status_t
AttrDirIterator::Close()
{
	if (!fDir)
		return B_BAD_VALUE;

	status_t error = B_OK;
	if (fs_close_attr_dir(fDir) < 0)
		error = errno;

	fDir = NULL;
	return error;
}

// ReadDir
status_t
AttrDirIterator::ReadDir(dirent* _entry, int32 bufferSize,
	int32 count, int32* countRead, bool* done)
{
// TODO: Burst read.
	if (!fDir)
		return B_ENTRY_NOT_FOUND;

	*countRead = 0;
	*done = false;

	if (count == 0)
		return B_OK;

	if (struct dirent* entry = fs_read_attr_dir(fDir)) {
		size_t entryLen = entry->d_name + strlen(entry->d_name) + 1
			- (char*)entry;
		memcpy(_entry, entry, entryLen);
		*countRead = 1;
	} else {
		*countRead = 0;
		*done = true;
	}
	return B_OK;
}

// RewindDir
status_t
AttrDirIterator::RewindDir()
{
	if (!fDir)
		return B_ENTRY_NOT_FOUND;

	fs_rewind_attr_dir(fDir);

	return B_OK;
}

// GetFD
int
AttrDirIterator::GetFD() const
{
	return dirfd(fDir);
}


// #pragma mark -

// QueryListener

// constructor
QueryListener::QueryListener()
{
}

// destructor
QueryListener::~QueryListener()
{
}


// #pragma mark -

// QueryHandle

// constructor
QueryHandle::QueryHandle(port_id remotePort, int32 remoteToken)
	: NodeHandle(),
	  fRemotePort(remotePort),
	  fRemoteToken(remoteToken),
	  fQueries(),
	  fCurrentQuery(NULL),
	  fListener(NULL),
	  fClosed(false)
{
}

// destructor
QueryHandle::~QueryHandle()
{
	Close();
}

// SetQueryListener
void
QueryHandle::SetQueryListener(QueryListener* listener)
{
	fListener = listener;
}

// GetQueryListener
QueryListener*
QueryHandle::GetQueryListener() const
{
	return fListener;
}

// AddQuery
void
QueryHandle::AddQuery(Query* query)
{
	if (query) {
		fQueries.Insert(query);
		if (!fCurrentQuery)
			fCurrentQuery = query;
	}
}

// RemoveQuery
void
QueryHandle::RemoveQuery(Query* query)
{
	if (query) {
		if (query == fCurrentQuery)
			fCurrentQuery = fQueries.GetNext(query);
		fQueries.Remove(query);
	}
}

// GetRemotePort
port_id
QueryHandle::GetRemotePort() const
{
	return fRemotePort;
}

// GetRemoteToken
int32
QueryHandle::GetRemoteToken() const
{
	return fRemoteToken;
}

// Close
status_t
QueryHandle::Close()
{
	if (fClosed)
		return B_OK;

	fCurrentQuery = NULL;

	// delete all queries
	for (DoublyLinkedList<Query>::Iterator it = fQueries.GetIterator();
			it.HasNext();) {
		Query* query = it.Next();
		it.Remove();
		delete query;
	}

	fClosed = true;

	if (fListener)
		fListener->QueryHandleClosed(this);

	return B_OK;
}

// ReadDir
status_t
QueryHandle::ReadDir(dirent* entry, int32 count, int32* countRead)
{
	if (count == 0) {
		*countRead = 0;
		return B_OK;
	}
	while (fCurrentQuery) {
		int32 readEntries = fCurrentQuery->GetNextDirents(entry,
			offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH, 1);
		if (readEntries < 0)
			return readEntries;
		if (readEntries > 0) {
			*countRead = 1;
			return B_OK;
		}
		fCurrentQuery = fQueries.GetNext(fCurrentQuery);
	}
	*countRead = 0;
	return B_OK;
}