haiku.git

// ClientConnection.cpp

#include "ClientConnection.h"

#include <new>
#include <typeinfo>

#include <dirent.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <utime.h>

#include <AutoDeleter.h>
#include <AutoLocker.h>
#include <Entry.h>
#include <fs_query.h>
#include <GraphicsDefs.h>
#include <HashMap.h>
#include <NodeMonitor.h>
#include <Path.h>
#include <Rect.h>
#include <Mime.h>

#include <fsproto.h>

#include "Compatibility.h"
#include "Connection.h"
#include "DebugSupport.h"
#include "Directory.h"
#include "Entry.h"
#include "FDManager.h"
#include "NodeHandle.h"
#include "NodeHandleMap.h"
#include "NodeMonitoringEvent.h"
#include "Path.h"
#include "RequestBufferReplacer.h"
#include "RequestChannel.h"
#include "RequestConnection.h"
#include "RequestDumper.h"
#include "RequestFlattener.h"
#include "Requests.h"
#include "SecurityContext.h"
#include "ServerNodeID.h"
#include "UserSecurityContext.h"
#include "Utils.h"
#include "Volume.h"
#include "VolumeManager.h"

static const int32 kMaxSaneReadLinkSize		= 10240;	// 10 KB
static const int32 kMaxReadBufferSize		= 10240;	// 10 KB
static const int32 kMaxReadDirBufferSize	= 10240;

// Locking:
//
// fLock: Guards fReferenceCount and fClosed.
// fSecurityContextLock: Guards fSecurityContext.
// fVolumes: Guards the map itself.


// #pragma mark -
// #pragma mark ----- ClientConnection -----

// ConnectionReference
class ClientConnection::ConnectionReference {
public:
	ConnectionReference(ClientConnection* connection)
		: fConnection(connection)
	{
		if (!fConnection || !fConnection->GetReference())
			fConnection = NULL;
	}

	~ConnectionReference()
	{
		if (fConnection)
			fConnection->PutReference();
	}

	bool IsValid() const
	{
		return fConnection;
	}

private:
	ClientConnection*	fConnection;
};

// VolumeMap
struct ClientConnection::VolumeMap
	: public SynchronizedHashMap<HashKey32<int32>, ClientVolume*> {
};

// ClientVolumePutter
class ClientConnection::ClientVolumePutter {
public:
	ClientVolumePutter(ClientConnection* connection, ClientVolume* volume)
		: fConnection(connection),
		  fVolume(volume)
	{
	}

	~ClientVolumePutter()
	{
		if (fConnection && fVolume)
			fConnection->_PutVolume(fVolume);
	}

	void Detach()
	{
		fConnection = NULL;
		fVolume = NULL;
	}

private:
	ClientConnection*	fConnection;
	ClientVolume*		fVolume;
};

// VolumeNodeMonitoringEvent
struct ClientConnection::VolumeNodeMonitoringEvent {
	VolumeNodeMonitoringEvent(int32 volumeID, NodeMonitoringEvent* event)
		: volumeID(volumeID),
		  event(event)
	{
		if (event)
			event->AcquireReference();
	}

	~VolumeNodeMonitoringEvent()
	{
		if (event)
			event->ReleaseReference();
	}

	int32					volumeID;
	NodeMonitoringEvent*	event;
};

// NodeMonitoringEventQueue
struct ClientConnection::NodeMonitoringEventQueue
	: BlockingQueue<NodeMonitoringRequest> {
	NodeMonitoringEventQueue()
		: BlockingQueue<NodeMonitoringRequest>("client NM requests")
	{
	}
};

// QueryHandleUnlocker
struct ClientConnection::QueryHandleUnlocker {
	QueryHandleUnlocker(ClientConnection* connection, NodeHandle* nodeHandle)
		: fConnection(connection),
		  fHandle(nodeHandle)
	{
	}

	~QueryHandleUnlocker()
	{
		if (fConnection && fHandle) {
			fConnection->_UnlockQueryHandle(fHandle);
			fConnection = NULL;
			fHandle = NULL;
		}
	}

private:
	ClientConnection*	fConnection;
	NodeHandle*			fHandle;
};

// ClientVolumeFilter
struct ClientConnection::ClientVolumeFilter {
	virtual ~ClientVolumeFilter() {}

	virtual bool FilterVolume(ClientConnection* connection,
		ClientVolume* volume) = 0;
};

// HasQueryPermissionClientVolumeFilter
struct ClientConnection::HasQueryPermissionClientVolumeFilter
	: ClientConnection::ClientVolumeFilter {
	virtual bool FilterVolume(ClientConnection* connection,
		ClientVolume* volume)
	{
		return volume->GetSharePermissions().ImpliesQuerySharePermission();
	}
};


// #pragma mark -

// constructor
ClientConnection::ClientConnection(Connection* connection,
	SecurityContext* securityContext, User* user,
	ClientConnectionListener* listener)
	: RequestHandler(),
	  ClientVolume::NodeMonitoringProcessor(),
	  fConnection(NULL),
	  fSecurityContext(securityContext),
	  fSecurityContextLock("security context lock"),
	  fUser(user),
	  fVolumes(NULL),
	  fQueryHandles(NULL),
	  fListener(listener),
	  fNodeMonitoringEvents(NULL),
	  fNodeMonitoringProcessor(-1),
	  fLock("client connection locker"),
	  fReferenceCount(0),
	  fInitialized(0),
	  fClosed(false),
	  fError(false),
	  fInverseClientEndianess(false)
{
	fConnection = new(std::nothrow) RequestConnection(connection, this);
	if (!fConnection)
		delete connection;
}

// destructor
ClientConnection::~ClientConnection()
{
	_Close();
	delete fConnection;

	// delete all volumes
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();)
		delete it.Next().value;
	delete fVolumes;

	delete fQueryHandles;
	delete fNodeMonitoringEvents;
}

// Init
status_t
ClientConnection::Init()
{
	// create a client volume map
	fVolumes = new(std::nothrow) VolumeMap;
	if (!fVolumes)
		return B_NO_MEMORY;
	status_t error = fVolumes->InitCheck();
	if (error != B_OK)
		return error;

	// create the query handle map
	fQueryHandles = new(std::nothrow) NodeHandleMap("query handles");
	if (!fQueryHandles)
		return B_NO_MEMORY;
	error = fQueryHandles->Init();
	if (error != B_OK)
		return error;

	// create the node monitoring event queue
	fNodeMonitoringEvents = new(std::nothrow) NodeMonitoringEventQueue;
	if (!fNodeMonitoringEvents)
		return B_NO_MEMORY;
	error = fNodeMonitoringEvents->InitCheck();
	if (error != B_OK)
		return error;

	// initialize the connection
	error = fConnection->Init();
	if (error != B_OK)
		return error;

	// start the node monitoring processor
	fNodeMonitoringProcessor = spawn_thread(_NodeMonitoringProcessorEntry,
		"client connection NM processor", B_NORMAL_PRIORITY, this);
	if (fNodeMonitoringProcessor < 0) {
		_Close();
		return fNodeMonitoringProcessor;
	}
	resume_thread(fNodeMonitoringProcessor);
	return B_OK;
}

// Close
/*!
	Called by the NetFSServer. Not for internal use. Waits for the connection
	to be closed (at least for the node monitoring thread to be gone).
*/
void
ClientConnection::Close()
{
	{
		ConnectionReference connectionReference(this);
		if (connectionReference.IsValid())
			_MarkClosed(false);
		fListener = NULL;
	}

	// Wait at least for the node monitoring processor; this is not perfect,
	// but not too bad either.
	if (fNodeMonitoringProcessor >= 0
		&& find_thread(NULL) != fNodeMonitoringProcessor) {
		int32 result;
		wait_for_thread(fNodeMonitoringProcessor, &result);
	}
}

// GetReference
bool
ClientConnection::GetReference()
{
	AutoLocker<Locker> _(fLock);
	if (fClosed || !atomic_or(&fInitialized, 0))
		return false;
	fReferenceCount++;
	return true;
}

// PutReference
void
ClientConnection::PutReference()
{
	bool close = false;
	{
		AutoLocker<Locker> _(fLock);
		--fReferenceCount;
		if (fClosed)
			close = (fReferenceCount == 0);
	}
	if (close)
		_Close();
}

// UserRemoved
void
ClientConnection::UserRemoved(User* user)
{
	// get all volumes
	ClientVolume** volumes = NULL;
	int32 volumeCount = 0;
	AutoLocker<VolumeMap> volumesLocker(fVolumes);
	volumes = new(std::nothrow) ClientVolume*[fVolumes->Size()];
	if (!volumes) {
		ERROR(("ClientConnection::UserRemoved(): ERROR: Failed to "
			"allocate memory for volume array.\n"));
		volumesLocker.Unlock();
		_UnmountAllVolumes();
		return;
	}
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
		if (ClientVolume* volume = _GetVolume(it.Next().value->GetID()))
			volumes[volumeCount++] = volume;
	}
	volumesLocker.Unlock();

	// unmount the concerned volumes
	for (int32 i = 0; i < volumeCount; i++) {
		ClientVolume* volume = volumes[i];

		fSecurityContextLock.Lock();
		bool unmount = (volume->GetSecurityContext()->GetUser() == user);
		fSecurityContextLock.Unlock();

		if (unmount)
			_UnmountVolume(volume);
	}

	// put the volumes
	for (int32 i = 0; i < volumeCount; i++)
		_PutVolume(volumes[i]);
	delete[] volumes;
}

// ShareRemoved
void
ClientConnection::ShareRemoved(Share* share)
{
	// get all volumes
	ClientVolume** volumes = NULL;
	int32 volumeCount = 0;
	AutoLocker<VolumeMap> volumesLocker(fVolumes);
	volumes = new(std::nothrow) ClientVolume*[fVolumes->Size()];
	if (!volumes) {
		ERROR(("ClientConnection::ShareRemoved(): ERROR: Failed to "
			"allocate memory for volume array.\n"));
		volumesLocker.Unlock();
		_UnmountAllVolumes();
		return;
	}
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
		if (ClientVolume* volume = _GetVolume(it.Next().value->GetID()))
			volumes[volumeCount++] = volume;
	}
	volumesLocker.Unlock();

	// unmount the concerned volumes
	for (int32 i = 0; i < volumeCount; i++) {
		ClientVolume* volume = volumes[i];

		fSecurityContextLock.Lock();
		bool unmount = (volume->GetShare() == share);
		fSecurityContextLock.Unlock();

		if (unmount)
			_UnmountVolume(volume);
	}

	// put the volumes
	for (int32 i = 0; i < volumeCount; i++)
		_PutVolume(volumes[i]);
	delete[] volumes;
}

// UserPermissionsChanged
void
ClientConnection::UserPermissionsChanged(Share* share, User* user,
	Permissions permissions)
{
	bool unmountAll = (!permissions.ImpliesMountSharePermission());

	// get all volumes
	ClientVolume** volumes = NULL;
	int32 volumeCount = 0;
	AutoLocker<VolumeMap> volumesLocker(fVolumes);
	volumes = new(std::nothrow) ClientVolume*[fVolumes->Size()];
	if (!volumes) {
		ERROR(("ClientConnection::ShareRemoved(): ERROR: Failed to "
			"allocate memory for volume array.\n"));
		volumesLocker.Unlock();
		_UnmountAllVolumes();
		return;
	}
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
		if (ClientVolume* volume = _GetVolume(it.Next().value->GetID()))
			volumes[volumeCount++] = volume;
	}
	volumesLocker.Unlock();

	// update the concerned volumes
	for (int32 i = 0; i < volumeCount; i++) {
		ClientVolume* volume = volumes[i];

		fSecurityContextLock.Lock();
		bool concerned = (volume->GetShare() == share
			&& volume->GetSecurityContext()->GetUser() == user);
		fSecurityContextLock.Unlock();

		if (concerned) {
			// create a new user security context for the volume
			status_t error = B_OK;

			if (unmountAll) {
				_UnmountVolume(volume);
			} else {
				// create a new user security context
				AutoLocker<Locker> securityContextLocker(fSecurityContextLock);
				UserSecurityContext* userSecurityContext
					= new(std::nothrow) UserSecurityContext;

				// init it
				if (userSecurityContext) {
					error = fSecurityContext->GetUserSecurityContext(user,
						userSecurityContext);
				} else
					error = B_NO_MEMORY;
				if (error != B_OK) {
					delete userSecurityContext;
					securityContextLocker.Unlock();
					_UnmountVolume(volume);
					continue;
				}

				// set the volume's new user security context
				securityContextLocker.Unlock();
				volume->SetSecurityContext(userSecurityContext);
			}
		}
	}

	// put the volumes
	for (int32 i = 0; i < volumeCount; i++)
		_PutVolume(volumes[i]);
	delete[] volumes;
}


// #pragma mark -

// VisitConnectionBrokenRequest
status_t
ClientConnection::VisitConnectionBrokenRequest(ConnectionBrokenRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	_MarkClosed(true);
	return B_OK;
}

// VisitInitConnectionRequest
status_t
ClientConnection::VisitInitConnectionRequest(InitConnectionRequest* request)
{
	bool alreadyInitialized = atomic_or(&fInitialized, ~0);

	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	if (!alreadyInitialized)
		fInverseClientEndianess = (request->bigEndian != B_HOST_IS_BENDIAN);

	// prepare the reply
	InitConnectionReply reply;

	// send the reply
	reply.error = (alreadyInitialized ? B_BAD_VALUE : B_OK);
	status_t error = GetChannel()->SendRequest(&reply);

	// on error just close
	if (error != B_OK)
		_MarkClosed(true);
	return B_OK;
}

// VisitMountRequest
status_t
ClientConnection::VisitMountRequest(MountRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	status_t result = B_OK;
	const char* shareName = request->share.GetString();
	if (!shareName)
		SET_ERROR(result, B_BAD_DATA);

	// create a volume
	ClientVolume* volume = NULL;
	if (result == B_OK)
		result = _CreateVolume(&volume);
	ClientVolumePutter volumePutter(this, volume);

	// if we haven't been supplied with a user yet, use the info from the
	// mount request for authentication
	VolumeManagerLocker managerLocker;
	AutoLocker<Locker> securityContextLocker(fSecurityContextLock);
	const char* userName = request->user.GetString();
	User* user = fUser;
	BReference<User> userReference(user);
	bool noPermission = false;
	if (result == B_OK && !user) {
		if (userName) {
			SET_ERROR(result, fSecurityContext->AuthenticateUser(userName,
				request->password.GetString(), &user));
			if (result == B_OK)
				userReference.SetTo(user, true);
		} else
			result = B_PERMISSION_DENIED;
		if (result == B_PERMISSION_DENIED)
			noPermission = true;
	}

	// create a user security context
	UserSecurityContext* securityContext = NULL;
	if (result == B_OK) {
		securityContext = new(std::nothrow) UserSecurityContext;
		if (securityContext) {
			SET_ERROR(result, fSecurityContext->GetUserSecurityContext(user,
				securityContext));
		} else
			SET_ERROR(result, B_NO_MEMORY);
	}
	ObjectDeleter<UserSecurityContext> securityContextDeleter(securityContext);

	// get the share
	Share* share = NULL;
	Permissions sharePermissions;
	node_ref mountPoint;
	if (result == B_OK) {
		AutoLocker<SecurityContext> _(fSecurityContext);
		share = fSecurityContext->FindShare(shareName);
		if (share) {
			mountPoint = share->GetNodeRef();
			sharePermissions = securityContext->GetNodePermissions(
				mountPoint);
			if (!sharePermissions.ImpliesMountSharePermission()) {
				SET_ERROR(result, B_PERMISSION_DENIED);
				noPermission = true;
			}
		} else
			SET_ERROR(result, B_ENTRY_NOT_FOUND);
	}
	BReference<Share> shareReference(share, true);

	// mount the volume
	MountReply reply;
	if (result == B_OK) {
		SET_ERROR(result, volume->Mount(securityContext, share));
		securityContextDeleter.Detach();
	}
	if (result == B_OK) {
		_GetNodeInfo(volume->GetRootDirectory(), &reply.nodeInfo);
		reply.sharePermissions = sharePermissions.GetPermissions();
		reply.volumeID = volume->GetID();
	}

	// make sure, the volume is removed on error
	if (result != B_OK && volume) {
		AutoLocker<VolumeMap> volumeMapLocker(fVolumes);
		volume->MarkRemoved();
	}

	securityContextLocker.Unlock();
	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	reply.noPermission = noPermission;
	return GetChannel()->SendRequest(&reply);
}

// VisitUnmountRequest
status_t
ClientConnection::VisitUnmountRequest(UnmountRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	if (ClientVolume* volume = _GetVolume(request->volumeID)) {
		_UnmountVolume(volume);
		_PutVolume(volume);
	}

	return B_OK;
}

// VisitReadVNodeRequest
status_t
ClientConnection::VisitReadVNodeRequest(ReadVNodeRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// prepare the reply
	ReadVNodeReply reply;
	if (result == B_OK)
		_GetNodeInfo(node, &reply.nodeInfo);

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitWriteStatRequest
status_t
ClientConnection::VisitWriteStatRequest(WriteStatRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the path
	Path path;
	if (result == B_OK)
		result = node->GetPath(&path);

	// write the stat
	uint32 mask = request->mask;
	// size
	if (result == B_OK && (mask & WSTAT_SIZE)) {
		if (truncate(path.GetPath(), request->nodeInfo.st.st_size) < 0)
			result = errno;
	}
	// mode
	if (result == B_OK && (mask & WSTAT_MODE)) {
		if (chmod(path.GetPath(), request->nodeInfo.st.st_mode) < 0)
			result = errno;
	}
	// mtime
	if (result == B_OK && (mask & (WSTAT_ATIME | WSTAT_MTIME))) {
		utimbuf buffer;
		buffer.actime = (mask & WSTAT_ATIME)
			? request->nodeInfo.st.st_atime
			: node->GetStat().st_atime;
		buffer.modtime = (mask & WSTAT_MTIME)
			? request->nodeInfo.st.st_mtime
			: node->GetStat().st_mtime;
		if (utime(path.GetPath(), &buffer) < 0)
			result = errno;
	}
	// ignore WSTAT_CRTIME, WSTAT_UID, WSTAT_GID for the time being

	// prepare the reply
	WriteStatReply reply;
	// update the node stat
	reply.nodeInfoValid = false;
	if (node) {
		if (node->UpdateStat() == B_OK) {
			_GetNodeInfo(node, &reply.nodeInfo);
			reply.nodeInfoValid = true;
		}
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitCreateFileRequest
status_t
ClientConnection::VisitCreateFileRequest(CreateFileRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->directoryID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	int openMode = request->openMode;
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the path
	Path path;
	if (result == B_OK) {
		result = directory->GetPath(&path);
		if (result == B_OK)
			result = path.Append(request->name.GetString());
	}

	// create the file
	if (result == B_OK) {
		int fd = -1;
		result = FDManager::Open(path.GetPath(),
			openMode | O_CREAT | O_NOTRAVERSE, request->mode, fd);
		if (result == B_OK)
			close(fd);
	}

	// load the new entry
	Entry* entry = NULL;
	if (result == B_OK) {
		VolumeManager* volumeManager = VolumeManager::GetDefault();

		// if there existed an entry before, we need to delete it, to avoid that
		// we open the wrong node
		entry = volumeManager->GetEntry(directory->GetVolumeID(),
			directory->GetID(), request->name.GetString());
		if (entry)
			volumeManager->DeleteEntry(entry, false);

		// load the new entry
		entry = NULL;
		result = volume->LoadEntry(directory, request->name.GetString(),
			&entry);
	}

	// open the node
	FileHandle* handle = NULL;
	if (result == B_OK) {
		openMode &= ~(O_CREAT | O_EXCL | O_TRUNC);
		result = volume->Open(entry->GetNode(), openMode, &handle);
	}
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// prepare the reply
	CreateFileReply reply;
	if (result == B_OK) {
		_GetEntryInfo(entry, &reply.entryInfo);
		reply.cookie = handle->GetCookie();
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	status_t error = GetChannel()->SendRequest(&reply);

	// close the handle, if a send error occurred
	if (error != B_OK && result == B_OK)
		volume->Close(handle);

	return error;
}

// VisitOpenRequest
status_t
ClientConnection::VisitOpenRequest(OpenRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	int openMode = request->openMode;
	if (result == B_OK) {
		Permissions permissions = volume->GetNodePermissions(node);
		if ((openMode & O_RWMASK) == O_RDWR) {
			// read+write: fall back to read/write only, if the other permission
			// is missing
			if (!permissions.ImpliesReadPermission())
				openMode = (openMode & ~O_RWMASK) | O_WRONLY;
			else if (!permissions.ImpliesWritePermission())
				openMode = (openMode & ~O_RWMASK) | O_RDONLY;
		}
		if ((openMode & O_RWMASK) == O_RDONLY) {
			if (!permissions.ImpliesReadPermission())
				result = B_PERMISSION_DENIED;
		} else if ((openMode & O_RWMASK) == O_WRONLY) {
			if (!permissions.ImpliesWritePermission())
				result = B_PERMISSION_DENIED;
		}
	}

	// open the node
	FileHandle* handle = NULL;
	if (result == B_OK)
		result = volume->Open(node, openMode, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// prepare the reply
	OpenReply reply;
	if (result == B_OK) {
		_GetNodeInfo(node, &reply.nodeInfo);
		reply.cookie = handle->GetCookie();
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	status_t error = GetChannel()->SendRequest(&reply);

	// close the handle, if a send error occurred
	if (error != B_OK && result == B_OK)
		volume->Close(handle);

	return error;
}

// VisitCloseRequest
status_t
ClientConnection::VisitCloseRequest(CloseRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	status_t result = B_OK;

	if (request->volumeID >= 0) {
		// get the volume
		ClientVolume* volume = _GetVolume(request->volumeID);
		if (!volume)
			SET_ERROR(result, B_BAD_VALUE);
		ClientVolumePutter volumePutter(this, volume);

		// get the node handle
		NodeHandle* handle = NULL;
		if (result == B_OK)
			SET_ERROR(result, volume->LockNodeHandle(request->cookie, &handle));
		NodeHandleUnlocker handleUnlocker(volume, handle);

		VolumeManagerLocker managerLocker;

		// close it
		if (result == B_OK)
			SET_ERROR(result, volume->Close(handle));

		managerLocker.Unlock();
	} else {
		// no volume ID given, so this is a query handle
		// lock the handle
		QueryHandle* handle = NULL;
		SET_ERROR(result, _LockQueryHandle(request->cookie, &handle));
		QueryHandleUnlocker handleUnlocker(this, handle);

		// close it
		if (result == B_OK)
			SET_ERROR(result, _CloseQuery(handle));
	}

	// send the reply
	CloseReply reply;
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitReadRequest
status_t
ClientConnection::VisitReadRequest(ReadRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	// get the node handle
	NodeHandle* handle = NULL;
	if (result == B_OK)
		result = volume->LockNodeHandle(request->cookie, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// check if it is a file handle
	FileHandle* fileHandle = NULL;
	if (result == B_OK) {
		fileHandle = dynamic_cast<FileHandle*>(handle);
		if (!fileHandle)
			result = B_BAD_VALUE;
	}

	VolumeManagerLocker managerLocker;

	// check read permission
	if (result == B_OK) {
		Node* node = volume->GetNode(fileHandle->GetNodeRef());
		if (!node || !volume->GetNodePermissions(node).ImpliesReadPermission())
			result = B_PERMISSION_DENIED;
	}

	managerLocker.Unlock();

	off_t pos = request->pos;
	int32 size = request->size;
	int32 bufferSize = min(size, kMaxReadBufferSize);
	// allocate a buffer
	uint8* buffer = NULL;
	if (result == B_OK) {
		buffer = (uint8*)malloc(bufferSize);
		if (!buffer)
			result = B_NO_MEMORY;
	}
	MemoryDeleter bufferDeleter(buffer);

	// read as long as there are bytes left to read or an error occurs
	bool moreToRead = true;
	do {
		int32 bytesToRead = min(size, bufferSize);
		size_t bytesRead = 0;
		if (result == B_OK)
			result = fileHandle->Read(pos, buffer, bytesToRead, &bytesRead);
		moreToRead = (result == B_OK && bytesRead > 0
			&& (int32)bytesRead < size);

		// prepare the reply
		ReadReply reply;
		if (result == B_OK) {
			reply.pos = pos;
			reply.data.SetTo(buffer, bytesRead);
			reply.moreToCome = moreToRead;
			pos += bytesRead;
			size -= bytesRead;
		}

		// send the reply
		reply.error = result;
		status_t error = GetChannel()->SendRequest(&reply);
		if (error != B_OK)
			return error;
	} while (moreToRead);

	return B_OK;
}

// VisitWriteRequest
status_t
ClientConnection::VisitWriteRequest(WriteRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	// get the node handle
	NodeHandle* handle = NULL;
	if (result == B_OK)
		result = volume->LockNodeHandle(request->cookie, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// check if it is a file handle
	FileHandle* fileHandle = NULL;
	if (result == B_OK) {
		fileHandle = dynamic_cast<FileHandle*>(handle);
		if (!fileHandle)
			result = B_BAD_VALUE;
	}

	VolumeManagerLocker managerLocker;

	// check read permission
	if (result == B_OK) {
		Node* node = volume->GetNode(fileHandle->GetNodeRef());
		if (!node || !volume->GetNodePermissions(node).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	managerLocker.Unlock();

	// write until all has been written or an error occurs
	off_t pos = request->pos;
	int32 size = request->data.GetSize();
	const char* buffer = (const char*)request->data.GetData();
	while (result == B_OK && size > 0) {
		size_t bytesWritten;
		result = fileHandle->Write(pos, buffer, size, &bytesWritten);
		if (result == B_OK) {
			pos += bytesWritten;
			buffer += bytesWritten;
			size -= bytesWritten;
		}
	}

	// prepare the reply
	WriteReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitCreateLinkRequest
status_t
ClientConnection::VisitCreateLinkRequest(CreateLinkRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the target node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// get the target node path
	Path targetPath;
	if (result == B_OK)
		result = node->GetPath(&targetPath);

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->directoryID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the new entry's path
	Path path;
	if (result == B_OK) {
		result = directory->GetPath(&path);
		if (result == B_OK)
			result = path.Append(request->name.GetString());
	}

	managerLocker.Unlock();

	// create the link
	if (result == B_OK) {
		if (link(targetPath.GetPath(), path.GetPath()) < 0)
			result = errno;
	}

	// prepare the reply
	CreateSymlinkReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitUnlinkRequest
status_t
ClientConnection::VisitUnlinkRequest(UnlinkRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->directoryID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the entry's path
	Path path;
	if (result == B_OK) {
		result = directory->GetPath(&path);
		if (result == B_OK)
			result = path.Append(request->name.GetString());
	}

	managerLocker.Unlock();

	// remove the entry
	if (result == B_OK) {
		if (unlink(path.GetPath()) < 0)
			result = errno;
	}

	// prepare the reply
	UnlinkReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitCreateSymlinkRequest
status_t
ClientConnection::VisitCreateSymlinkRequest(CreateSymlinkRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->directoryID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the new entry's path
	Path path;
	if (result == B_OK) {
		result = directory->GetPath(&path);
		if (result == B_OK)
			result = path.Append(request->name.GetString());
	}

	managerLocker.Unlock();

	// create the symlink
	if (result == B_OK) {
		if (symlink(request->target.GetString(), path.GetPath()) < 0)
			result = errno;
	}

	// prepare the reply
	CreateSymlinkReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitReadLinkRequest
status_t
ClientConnection::VisitReadLinkRequest(ReadLinkRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	int32 bufferSize = request->maxSize;

	// check read permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesReadPermission())
			result = B_PERMISSION_DENIED;
	}

	// allocate a buffer
	void* buffer = NULL;
	if (result == B_OK) {
		if (bufferSize < 0 || bufferSize > kMaxSaneReadLinkSize)
			result = B_BAD_DATA;
	}
	if (result == B_OK) {
		buffer = malloc(bufferSize);
		if (!buffer)
			result = B_NO_MEMORY;
	}
	MemoryDeleter bufferDeleter(buffer);

	// read the link and prepare the reply
	ReadLinkReply reply;
	int32 bytesRead = 0;
	if (result == B_OK)
		result = node->ReadSymlink((char*)buffer, bufferSize, &bytesRead);
	if (result == B_OK) {
		reply.data.SetTo(buffer, bytesRead);
		_GetNodeInfo(node, &reply.nodeInfo);
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitRenameRequest
status_t
ClientConnection::VisitRenameRequest(RenameRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the new directory
	Directory* newDirectory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->newDirectoryID);
		if (node) {
			newDirectory = dynamic_cast<Directory*>(node);
			if (!newDirectory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(newDirectory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the new path
	Path newPath;
	if (result == B_OK) {
		result = newDirectory->GetPath(&newPath);
		if (result == B_OK)
			result = newPath.Append(request->newName.GetString());
	}

	// get the old directory
	Directory* oldDirectory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->oldDirectoryID);
		if (node) {
			oldDirectory = dynamic_cast<Directory*>(node);
			if (!oldDirectory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(oldDirectory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the new path
	Path oldPath;
	if (result == B_OK) {
		result = oldDirectory->GetPath(&oldPath);
		if (result == B_OK)
			result = oldPath.Append(request->oldName.GetString());
	}

	managerLocker.Unlock();

	// rename the entry
	if (result == B_OK) {
		if (rename(oldPath.GetPath(), newPath.GetPath()) < 0)
			result = errno;
	}

	// prepare the reply
	RenameReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitMakeDirRequest
status_t
ClientConnection::VisitMakeDirRequest(MakeDirRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->directoryID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the path
	Path path;
	if (result == B_OK) {
		result = directory->GetPath(&path);
		if (result == B_OK)
			result = path.Append(request->name.GetString());
	}

	managerLocker.Unlock();

	// create the directory
	if (result == B_OK) {
		if (mkdir(path.GetPath(), request->mode) < 0)
			result = errno;
	}

	// prepare the reply
	MakeDirReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitRemoveDirRequest
status_t
ClientConnection::VisitRemoveDirRequest(RemoveDirRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->directoryID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permissions
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// get the path
	Path path;
	if (result == B_OK) {
		result = directory->GetPath(&path);
		if (result == B_OK)
			result = path.Append(request->name.GetString());
	}

	managerLocker.Unlock();

	// remove the directory
	if (result == B_OK) {
		if (rmdir(path.GetPath()) < 0)
			result = errno;
	}

	// prepare the reply
	RemoveDirReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitOpenDirRequest
status_t
ClientConnection::VisitOpenDirRequest(OpenDirRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->nodeID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesReadDirPermission())
			result = B_PERMISSION_DENIED;
	}

	// open the directory
	DirIterator* handle = NULL;
	if (result == B_OK)
		result = volume->OpenDir(directory, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// prepare the reply
	OpenDirReply reply;
	if (result == B_OK) {
		_GetNodeInfo(directory, &reply.nodeInfo);
		reply.cookie = handle->GetCookie();
	} else {
		if (directory != NULL) {
			PRINT("OpenDir() failed: client volume: %" B_PRId32 ", "
				"node: (%" B_PRIdDEV ", %" B_PRIdINO ")\n",
				volume->GetID(), directory->GetVolumeID(), directory->GetID());
		}
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	status_t error = GetChannel()->SendRequest(&reply);

	// close the handle, if a send error occurred
	if (error != B_OK && result == B_OK)
		volume->Close(handle);

	return error;
}

// VisitReadDirRequest
status_t
ClientConnection::VisitReadDirRequest(ReadDirRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	// get the node handle
	NodeHandle* handle = NULL;
	if (result == B_OK)
		result = volume->LockNodeHandle(request->cookie, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// check if it is a directory iterator
	DirIterator* iterator = NULL;
	if (result == B_OK) {
		iterator = dynamic_cast<DirIterator*>(handle);
		if (!iterator)
			result = B_BAD_VALUE;
	}

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(iterator->GetNodeRef());
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check read permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory).ImpliesReadDirPermission())
			result = B_PERMISSION_DENIED;
	}

	if (result == B_OK) {
		PRINT("ReadDir: (%" B_PRId32 ", %" B_PRIdINO ")\n", request->volumeID,
			directory->GetID());
	}

	// rewind, if requested
	if (result == B_OK && request->rewind)
		iterator->Rewind();

	// read the directory
	bool done = false;
	ReadDirReply reply;
	int32 toRead = request->count;
	while (result == B_OK && toRead > 0) {
		// get the next entry
		Entry* entry = iterator->NextEntry();
		if (!entry) {
			done = true;
			break;
		}

		// get and add an entry info
		EntryInfo entryInfo;
		_GetEntryInfo(entry, &entryInfo);
		result = reply.entryInfos.Append(entryInfo);

		toRead--;
	}

	reply.revision = VolumeManager::GetDefault()->GetRevision();

//PRINT(("ReadDir: (%lld) -> (%lx, %ld, dir: %lld, node: %lld, `%s')\n",
//directoryID, reply.error, reply.entryInfos.CountElements(),
//reply.entryInfo.directoryID,
//reply.entryInfo.nodeID, reply.entryInfo.name.GetString()));
	if (directory != NULL) {
		PRINT("ReadDir done: volume: %" B_PRId32 ", "
			"(%" B_PRIdDEV ", %" B_PRIdINO ") -> "
			"(%" B_PRIx32 ", %" B_PRId32 ")\n",
			volume->GetID(), directory->GetVolumeID(), directory->GetID(),
			result, reply.entryInfos.CountElements());
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	reply.done = (result != B_OK || done);
	return GetChannel()->SendRequest(&reply);
}

// VisitWalkRequest
status_t
ClientConnection::VisitWalkRequest(WalkRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->nodeID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory)
				.ImpliesResolveDirEntryPermission()) {
			result = B_PERMISSION_DENIED;
		}
	}

	WalkReply reply;
	char linkPath[B_PATH_NAME_LENGTH];
	if (result == B_OK) {
		// load the entry
		Entry* entry;
		result = volume->LoadEntry(directory, request->name.GetString(),
			&entry);

		// fill in the reply
		if (result == B_OK) {
			_GetEntryInfo(entry, &reply.entryInfo);

			// resolve a symlink, if desired
			Node* node = entry->GetNode();
			if (request->resolveLink && node->IsSymlink()) {
				result = node->ReadSymlink(linkPath, B_PATH_NAME_LENGTH);
				if (result == B_OK)
					reply.linkPath.SetTo(linkPath);
			}
		}
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	PRINT("Walk: (%" B_PRIdDEV ", %" B_PRIdINO ", `%s') -> "
		"(%" B_PRIx32 ", (%" B_PRIdDEV ", %" B_PRIdINO "), `%s')\n",
		request->nodeID.volumeID, request->nodeID.nodeID,
		request->name.GetString(), result,
		reply.entryInfo.nodeInfo.st.st_dev,
		reply.entryInfo.nodeInfo.st.st_ino, reply.linkPath.GetString());
	return GetChannel()->SendRequest(&reply);
}

// VisitMultiWalkRequest
status_t
ClientConnection::VisitMultiWalkRequest(MultiWalkRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the directory
	Directory* directory = NULL;
	if (result == B_OK) {
		Node* node = volume->GetNode(request->nodeID);
		if (node) {
			directory = dynamic_cast<Directory*>(node);
			if (!directory)
				result = B_NOT_A_DIRECTORY;
		} else
			result = B_ENTRY_NOT_FOUND;
	}

	// check permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(directory)
				.ImpliesResolveDirEntryPermission()) {
			result = B_PERMISSION_DENIED;
		}
	}

	MultiWalkReply reply;
	StringData* names = request->names.GetElements();
	int32 count = request->names.CountElements();
	for (int32 i = 0; result == B_OK && i < count; i++) {
		// load the entry
		Entry* entry;
		if (volume->LoadEntry(directory, names[i].GetString(), &entry)
				== B_OK) {
			// add an entry info
			EntryInfo entryInfo;
			_GetEntryInfo(entry, &entryInfo);

			// append the info
			result = reply.entryInfos.Append(entryInfo);
		}
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	PRINT("MultiWalk: (%" B_PRIdDEV ", %" B_PRIdINO ", %" B_PRId32 ") -> "
		"(%" B_PRIx32 ", %" B_PRId32 ")\n",
		request->nodeID.volumeID, request->nodeID.nodeID, count,
		result, reply.entryInfos.CountElements());
	return GetChannel()->SendRequest(&reply);
}

// VisitOpenAttrDirRequest
status_t
ClientConnection::VisitOpenAttrDirRequest(OpenAttrDirRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesReadPermission())
			result = B_PERMISSION_DENIED;
	}

	// load/cache the attribute directory
	bool attrDirCached = (node->LoadAttrDir() == B_OK);

	// open the attribute directory, if caching it failed
	AttrDirIterator* handle = NULL;
	if (result == B_OK && !attrDirCached)
		result = volume->OpenAttrDir(node, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// prepare the reply
	OpenAttrDirReply reply;
	if (result == B_OK) {
		if (handle) {
			reply.cookie = handle->GetCookie();
		} else {
			// the attribute directory is cached
			reply.cookie = -1;
			result = _GetAttrDirInfo(request, node, &reply.attrDirInfo);
		}
	}

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	status_t error = GetChannel()->SendRequest(&reply);

	// close the handle, if a send error occurred
	if (error != B_OK && result == B_OK && handle)
		volume->Close(handle);

	return error;
}

// VisitReadAttrDirRequest
status_t
ClientConnection::VisitReadAttrDirRequest(ReadAttrDirRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	// get the node handle
	NodeHandle* handle = NULL;
	if (result == B_OK)
		result = volume->LockNodeHandle(request->cookie, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	// check if it is a attribute directory iterator
	AttrDirIterator* iterator = NULL;
	if (result == B_OK) {
		iterator = dynamic_cast<AttrDirIterator*>(handle);
		if (!iterator)
			result = B_BAD_VALUE;
	}

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(iterator->GetNodeRef());
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check read permission (we already checked when opening, but anyway...)
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesReadPermission())
			result = B_PERMISSION_DENIED;
	}

	managerLocker.Unlock();

	// read the attribute directory
	uint8 buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH];
	struct dirent* dirEntry = (struct dirent*)buffer;
	int32 countRead = 0;
	bool done = true;
	if (result == B_OK) {
		if (request->rewind)
			result = iterator->RewindDir();
		if (result == B_OK) {
			result = iterator->ReadDir(dirEntry, sizeof(buffer), 1,
				&countRead, &done);
		}
	}

	// prepare the reply
	ReadAttrDirReply reply;
	reply.name.SetTo(dirEntry->d_name);

	// send the reply
	reply.error = result;
	reply.count = countRead;
	return GetChannel()->SendRequest(&reply);
}

// VisitReadAttrRequest
status_t
ClientConnection::VisitReadAttrRequest(ReadAttrRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check read permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesReadPermission())
			result = B_PERMISSION_DENIED;
	}

	// open the node
	FileHandle* handle = NULL;
	if (result == B_OK)
		result = volume->Open(node, O_RDONLY, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	managerLocker.Unlock();

	// read the attribute
	if (result == B_OK) {
		// Due to a bug in BFS the `pos' is ignored. This means that the loop
		// below won't work if the attribute is non-empty and the buffer is
		// larger than the attribute, because the we would again and again
		// read the beginning of the attribute until the buffer is full.
		// Hence we first get an attr_info and don't try to read more than
		// the size of the attribute.
		attr_info info;
		result = handle->StatAttr(request->name.GetString(), &info);
		off_t originalPos = max(request->pos, (off_t)0);
		int32 originalSize = max(request->size, (int32)0);
		off_t pos = originalPos;
		int32 size = originalSize;
		type_code type = B_SWAP_INT32(request->type);
		bool convert = false;

		if (result == B_OK) {
			originalSize = min((off_t)originalSize, max((off_t)0, info.size - pos));
			size = originalSize;

			// deal with inverse endianess clients
			if (fInverseClientEndianess) {
				convert = _KnownAttributeType(info.type);
				if (convert) {
					// read the whole attribute
					pos = 0;
					size = info.size;
				} else
					type = B_SWAP_INT32(request->type);
			}
		}
		int32 bufferSize = min(size, kMaxReadBufferSize);

		// allocate a buffer
		uint8* buffer = NULL;
		if (result == B_OK) {
			buffer = (uint8*)malloc(bufferSize);
			if (!buffer)
				result = B_NO_MEMORY;
		}
		MemoryDeleter bufferDeleter(buffer);

		if (convert) {
			// read the whole attribute and convert it
			if (result == B_OK) {
				// read
				size_t bytesRead = 0;
				result = handle->ReadAttr(request->name.GetString(),
					type, 0, buffer, size, &bytesRead);
				if (result == B_OK && (int32)bytesRead != size)
					result = B_ERROR;

				// convert
				if (result == B_OK)
					_ConvertAttribute(info, buffer);
			}

			// prepare the reply
			ReadAttrReply reply;
			if (result == B_OK) {
				reply.pos = originalPos;
				reply.data.SetTo(buffer + originalPos, originalSize);
				reply.moreToCome = false;
			}

			// send the reply
			reply.error = result;
			status_t error = GetChannel()->SendRequest(&reply);
			if (error != B_OK)
				return error;
		} else {
			// read as long as there are bytes left to read or an error occurs
			bool moreToRead = true;
			do {
				int32 bytesToRead = min(size, bufferSize);
				size_t bytesRead = 0;
				if (result == B_OK) {
					result = handle->ReadAttr(request->name.GetString(),
						request->type, pos, buffer, bytesToRead, &bytesRead);
				}
				moreToRead = (result == B_OK && bytesRead > 0
					&& (int32)bytesRead < size);

				// prepare the reply
				ReadAttrReply reply;
				if (result == B_OK) {
					reply.pos = pos;
					reply.data.SetTo(buffer, bytesRead);
					reply.moreToCome = moreToRead;
					pos += bytesRead;
					size -= bytesRead;
				}

				// send the reply
				reply.error = result;
				status_t error = GetChannel()->SendRequest(&reply);
				if (error != B_OK)
					return error;
			} while (moreToRead);
		}

		// close the handle
		volume->Close(handle);
	} else {
		// opening the node failed (or something even earlier): send an error
		// reply
		ReadAttrReply reply;
		reply.error = result;
		status_t error = GetChannel()->SendRequest(&reply);
		if (error != B_OK)
			return error;
	}

	return B_OK;
}

// VisitWriteAttrRequest
status_t
ClientConnection::VisitWriteAttrRequest(WriteAttrRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check read permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// open the node
	FileHandle* handle = NULL;
	if (result == B_OK)
		result = volume->Open(node, O_RDWR, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	managerLocker.Unlock();

	if (result == B_OK) {
		off_t pos = max(request->pos, (off_t)0);
		int32 size = request->data.GetSize();
		type_code type = request->type;
		char* buffer = (char*)request->data.GetData();

		// convert the data, if necessary
		if (fInverseClientEndianess) {
			if (_KnownAttributeType(type)) {
				if (pos != 0) {
					WARN("WriteAttr(): WARNING: Need to convert attribute "
						"endianess, but position is not 0: attribute: %s, "
						"pos: %" B_PRIdOFF ", size: %" B_PRId32 "\n",
						request->name.GetString(), pos, size);
				}
				swap_data(type, buffer, size, B_SWAP_ALWAYS);
			} else
				type = B_SWAP_INT32(type);
		}

		// write the data
		while (result == B_OK && size > 0) {
			size_t bytesWritten;
			result = handle->WriteAttr(request->name.GetString(),
				type, pos, buffer, size, &bytesWritten);
			if (result == B_OK) {
				pos += bytesWritten;
				buffer += bytesWritten;
				size -= bytesWritten;
			}
		}

		// close the handle
		volume->Close(handle);
	}

	// prepare the reply
	WriteAttrReply reply;
	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitRemoveAttrRequest
status_t
ClientConnection::VisitRemoveAttrRequest(RemoveAttrRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check read permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesWritePermission())
			result = B_PERMISSION_DENIED;
	}

	// open the node
	FileHandle* handle = NULL;
	if (result == B_OK)
		result = volume->Open(node, O_RDWR, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	managerLocker.Unlock();

	// remove the attribute and close the node
	if (result == B_OK) {
		result = handle->RemoveAttr(request->name.GetString());
		volume->Close(handle);
	}

	// send the reply
	RemoveAttrReply reply;
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitRenameAttrRequest
status_t
ClientConnection::VisitRenameAttrRequest(RenameAttrRequest* request)
{
	// Not supported, since there's no API function to rename an attribute.
	// send the reply
	RemoveAttrReply reply;
	reply.error = B_UNSUPPORTED;
	return GetChannel()->SendRequest(&reply);
}

// VisitStatAttrRequest
status_t
ClientConnection::VisitStatAttrRequest(StatAttrRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// get the volume
	status_t result = B_OK;
	ClientVolume* volume = _GetVolume(request->volumeID);
	if (!volume)
		result = B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	VolumeManagerLocker managerLocker;

	// get the node
	Node* node = NULL;
	if (result == B_OK) {
		node = volume->GetNode(request->nodeID);
		if (!node)
			result = B_ENTRY_NOT_FOUND;
	}

	// check read permission
	if (result == B_OK) {
		if (!volume->GetNodePermissions(node).ImpliesReadPermission())
			result = B_PERMISSION_DENIED;
	}

	// open the node
	FileHandle* handle = NULL;
	if (result == B_OK)
		result = volume->Open(node, O_RDONLY, &handle);
	NodeHandleUnlocker handleUnlocker(volume, handle);

	managerLocker.Unlock();

	// stat the attribute and close the node
	attr_info attrInfo;
	StatAttrReply reply;
	if (result == B_OK) {
		result = handle->StatAttr(request->name.GetString(), &attrInfo);
		volume->Close(handle);
	}

	// set the attribute info
	if (result == B_OK) {
		result = _GetAttrInfo(request, request->name.GetString(), attrInfo,
			NULL, &reply.attrInfo);
	}

	// send the reply
	reply.error = result;
	return GetChannel()->SendRequest(&reply);
}

// VisitOpenQueryRequest
status_t
ClientConnection::VisitOpenQueryRequest(OpenQueryRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	VolumeManagerLocker managerLocker;

	// open the query
	status_t result;
	QueryHandle* handle = NULL;
	result = _OpenQuery(request->queryString.GetString(),
			request->flags, request->port, request->token, &handle);
	QueryHandleUnlocker handleUnlocker(this, handle);

	// prepare the reply
	OpenQueryReply reply;
	if (result == B_OK)
		reply.cookie = handle->GetCookie();

	managerLocker.Unlock();

	// send the reply
	reply.error = result;
	status_t error = GetChannel()->SendRequest(&reply);

	// close the handle, if a send error occurred
	if (error != B_OK && result == B_OK)
		_CloseQuery(handle);

	return error;
}

// VisitReadQueryRequest
status_t
ClientConnection::VisitReadQueryRequest(ReadQueryRequest* request)
{
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return B_OK;

	// create an array for the IDs of the client volumes a found entry may
	// reside on
	status_t result = B_OK;
	int32 volumeCount = fVolumes->Size();
	int32* volumeIDs = new(std::nothrow) int32[volumeCount];
	if (!volumeIDs)
		result = B_NO_MEMORY;

	ArrayDeleter<int32> volumeIDsDeleter(volumeIDs);

	// get the query handle
	QueryHandle* handle = NULL;
	if (result == B_OK)
		result = _LockQueryHandle(request->cookie, &handle);
	QueryHandleUnlocker handleUnlocker(this, handle);

	// check if it is a query handle
	QueryHandle* queryHandle = NULL;
	if (result == B_OK) {
		queryHandle = dynamic_cast<QueryHandle*>(handle);
		if (!queryHandle)
			result = B_BAD_VALUE;
	}

	// read the query
	ReadQueryReply reply;
	int32 countRead = 0;
	while (result == B_OK) {
		uint8 buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH];
		struct dirent* dirEntry = (struct dirent*)buffer;

		result = queryHandle->ReadDir(dirEntry, 1, &countRead);
		if (result != B_OK)
			break;
		if (countRead == 0)
			break;
		PRINT("  query entry: %" B_PRIdDEV ", %" B_PRIdINO ", \"%s\"\n",
			dirEntry->d_pdev, dirEntry->d_pino, dirEntry->d_name);

		VolumeManagerLocker managerLocker;
		VolumeManager* volumeManager = VolumeManager::GetDefault();

		// load the entry
		Entry* entry = NULL;
		result = volumeManager->LoadEntry(dirEntry->d_pdev,
			dirEntry->d_pino, dirEntry->d_name, true, &entry);

		// if at least one client volume contains the entry, get an entry info
		if (result == B_OK) {
			HasQueryPermissionClientVolumeFilter filter;
			int32 entryVolumeCount = _GetContainingClientVolumes(
				entry->GetDirectory(), volumeIDs, volumeCount, &filter);
			if (entryVolumeCount > 0) {
				// store all the client volume IDs in the reply
				for (int32 i = 0; i < entryVolumeCount; i++) {
					result = reply.clientVolumeIDs.Append(volumeIDs[i]);
					if (result != B_OK)
						break;
				}

				// get an entry info
				_GetNodeInfo(entry->GetDirectory(), &reply.dirInfo);
				_GetEntryInfo(entry, &reply.entryInfo);
				break;
			} else
				PRINT(("  -> no client volumes\n"));
		}

		// entry is not in the volume: next round...
		result = B_OK;
	}

	// send the reply
	reply.error = result;
	reply.count = countRead;
	PRINT("ReadQuery: (%" B_PRIx32 ", %" B_PRId32 ", "
		"dir: (%" B_PRIdDEV ", %" B_PRIdINO "), "
		"node: (%" B_PRIdDEV ", %" B_PRIdINO ", `%s')\n",
		reply.error, reply.count,
		reply.entryInfo.directoryID.volumeID,
		reply.entryInfo.directoryID.nodeID,
		reply.entryInfo.nodeInfo.st.st_dev,
		reply.entryInfo.nodeInfo.st.st_ino,
		reply.entryInfo.name.GetString());
	return GetChannel()->SendRequest(&reply);
}


// #pragma mark -

// ProcessNodeMonitoringEvent
void
ClientConnection::ProcessNodeMonitoringEvent(int32 volumeID,
	NodeMonitoringEvent* event)
{
	// get a connection reference
	ConnectionReference connectionReference(this);
	if (!connectionReference.IsValid())
		return;

	_PushNodeMonitoringEvent(volumeID, event);
}

// CloseNodeMonitoringEventQueue
void
ClientConnection::CloseNodeMonitoringEventQueue()
{
	typedef Vector<NodeMonitoringRequest*> RequestVector;
	const RequestVector* requests = NULL;
	if (fNodeMonitoringEvents->Close(false, &requests) == B_OK) {
		for (RequestVector::ConstIterator it = requests->Begin();
			 it != requests->End();
			 it++) {
			delete *it;
		}
	}
}


// #pragma mark -

// QueryDomainIntersectsWith
bool
ClientConnection::QueryDomainIntersectsWith(Volume* volume)
{
	// Iterate through the the client volumes and check whether any one contains
	// the supplied volume or its root dir is on the volume. We don't check
	// directory inclusion for the latter, since we don't need to query the
	// volume, if the client volume is located on a volume mounted somewhere
	// under the supplied volume (e.g. the root FS contains everything, but does
	// seldomly need to be queried).
	VolumeManager* volumeManager = VolumeManager::GetDefault();
	AutoLocker<VolumeMap> volumesLocker(fVolumes);
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
		ClientVolume* clientVolume = it.Next().value;
		Directory* volumeRoot = volume->GetRootDirectory();
		Directory* clientVolumeRoot = clientVolume->GetRootDirectory();
		if (volumeManager->DirectoryContains(clientVolumeRoot, volumeRoot, true)
			|| volumeRoot->GetVolumeID() == clientVolumeRoot->GetVolumeID()) {
			return true;
		}
	}

	return false;
}

// ProcessQueryEvent
void
ClientConnection::ProcessQueryEvent(NodeMonitoringEvent* event)
{
	dev_t volumeID;
	ino_t directoryID;
	if (event->opcode == B_ENTRY_CREATED) {
		// "entry created" event
		EntryCreatedEvent* createdEvent
			= dynamic_cast<EntryCreatedEvent*>(event);
		if (!createdEvent)
			return;
		volumeID = createdEvent->volumeID;
		directoryID = createdEvent->directoryID;

	} else if (event->opcode == B_ENTRY_REMOVED) {
		// "entry removed" event
		EntryRemovedEvent* removedEvent
			= dynamic_cast<EntryRemovedEvent*>(event);
		if (!removedEvent)
			return;
		volumeID = removedEvent->volumeID;
		directoryID = removedEvent->directoryID;

	} else {
		// We only support "entry created" and "entry removed" query events.
		// "entry moved" is split by the volume manager into those.
		ERROR("Ignoring unexpected query event: opcode: 0x%" B_PRIx32 "\n",
			event->opcode);
		return;
	}
	PRINT("ClientConnection::ProcessQueryEvent(): event: %p, type: %s:"
		" directory: (%" B_PRIdDEV ", %" B_PRIdINO ")\n",
		event, typeid(event).name(), volumeID, directoryID);

	// create an array for the IDs of the client volumes a found entry may
	// reside on
	int32 volumeCount = fVolumes->Size();
	int32* volumeIDs = new(std::nothrow) int32[volumeCount];
	if (!volumeIDs)
		return;

	ArrayDeleter<int32> volumeIDsDeleter(volumeIDs);

	HasQueryPermissionClientVolumeFilter filter;

	// load the directory the concerned entry belongs/belonged to
	Directory* directory;
	int32 concernedVolumes = 0;
	if (VolumeManager::GetDefault()->LoadDirectory(volumeID, directoryID,
			&directory) == B_OK) {
		// find out, which client volumes the directory is located in
		concernedVolumes = _GetContainingClientVolumes(directory, volumeIDs,
			volumeCount, &filter);
	} else {
		// Failed to load the directory, so maybe it has already been
		// deleted. For "entry removed" events, we consider all client
		// volumes to be notified -- those that don't know the entry will
		// ignore the event.
		if (event->opcode == B_ENTRY_REMOVED) {
			concernedVolumes = _GetAllClientVolumeIDs(volumeIDs, volumeCount,
				&filter);
		}
	}

	// now push the event for each concerned client volume
	for (int32 i = 0; i < concernedVolumes; i++)
		_PushNodeMonitoringEvent(volumeIDs[i], event);
	// TODO: More than one volume will usually only be concerned in case of
	// nested client volumes. We could optimize the case by having an array of
	// volume IDs in the respective requests sent over the net (just as in the
	// ReadQueryReply).
}


// #pragma mark -

// _Close
void
ClientConnection::_Close()
{
	// terminate node monitoring processor
	CloseNodeMonitoringEventQueue();
	if (fNodeMonitoringProcessor >= 0
		&& find_thread(NULL) != fNodeMonitoringProcessor) {
		int32 result;
		wait_for_thread(fNodeMonitoringProcessor, &result);
		// The variable is not unset, when this is the node monitoring
		// processor thread -- which is good, since the destructor will
		// wait for the thread in this case.
		fNodeMonitoringProcessor = -1;
	}
	if (fConnection)
		fConnection->Close();
	// notify the listener
	ClientConnectionListener* listener = fListener;
	fListener = NULL;
	if (listener)
		listener->ClientConnectionClosed(this, fError);
}

// _MarkClosed
void
ClientConnection::_MarkClosed(bool error)
{
	AutoLocker<Locker> _(fLock);
	if (!fClosed) {
		fClosed = true;
		fError = error;
	}
}

// _GetNodeInfo
void
ClientConnection::_GetNodeInfo(Node* node, NodeInfo* info)
{
	if (node && info) {
		info->st = node->GetStat();
		info->revision = VolumeManager::GetDefault()->GetRevision();
	}
}

// _GetEntryInfo
void
ClientConnection::_GetEntryInfo(Entry* entry, EntryInfo* info)
{
	if (entry && info) {
		info->directoryID.volumeID = entry->GetVolumeID();
		info->directoryID.nodeID = entry->GetDirectoryID();
		info->name.SetTo(entry->GetName());
		_GetNodeInfo(entry->GetNode(), &info->nodeInfo);
	}
}

// _GetAttrInfo
status_t
ClientConnection::_GetAttrInfo(Request* request, const char* name,
	const attr_info& attrInfo, const void* data, AttributeInfo* info)
{
	if (!request || !name || !info)
		return B_BAD_VALUE;

	info->name.SetTo(name);
	info->info = attrInfo;
	data = (attrInfo.size > 0 ? data : NULL);
	int32 dataSize = (data ? attrInfo.size : 0);
	info->data.SetTo(data, dataSize);

	// if the client has inverse endianess, swap the type, if we don't know it
	if (fInverseClientEndianess) {
		if (_KnownAttributeType(info->info.type)) {
			// we need to convert the data, if supplied
			if (data) {
				// allocate a buffer
				RequestBuffer* requestBuffer = RequestBuffer::Create(dataSize);
				if (!requestBuffer)
					return B_NO_MEMORY;

				// convert the data
				memcpy(requestBuffer->GetData(), data, dataSize);
				_ConvertAttribute(info->info, requestBuffer->GetData());
			}
		} else
			info->info.type = B_SWAP_INT32(info->info.type);
	}

	return B_OK;
}

// _GetAttrDirInfo
status_t
ClientConnection::_GetAttrDirInfo(Request* request, AttributeDirectory* attrDir,
	AttrDirInfo* info)
{
	if (!request || !attrDir || !info || !attrDir->IsAttrDirValid())
		return B_BAD_VALUE;

	// add the attribute infos
	for (Attribute* attribute = attrDir->GetFirstAttribute();
		 attribute;
		 attribute = attrDir->GetNextAttribute(attribute)) {
		// get the attribute info
		AttributeInfo attrInfo;
		attr_info bAttrInfo;
		attribute->GetInfo(&bAttrInfo);
		status_t error = _GetAttrInfo(request, attribute->GetName(), bAttrInfo,
			attribute->GetData(), &attrInfo);

		// append it
		if (error == B_OK)
			error = info->attributeInfos.Append(attrInfo);
		if (error != B_OK)
			return error;
	}

	info->revision = VolumeManager::GetDefault()->GetRevision();
	info->isValid = true;

	return B_OK;
}

// _CreateVolume
status_t
ClientConnection::_CreateVolume(ClientVolume** _volume)
{
	// create and init the volume
	ClientVolume* volume = new(std::nothrow) ClientVolume(fSecurityContextLock,
		this);
	if (!volume)
		return B_NO_MEMORY;
	status_t error = volume->Init();
	if (error != B_OK) {
		delete volume;
		return error;
	}

	// add it to the volume map
	AutoLocker<VolumeMap> locker(fVolumes);
	error = fVolumes->Put(volume->GetID(), volume);
	locker.Unlock();

	if (error == B_OK)
		*_volume = volume;
	else
		delete volume;

	return error;
}

// _GetVolume
ClientVolume*
ClientConnection::_GetVolume(int32 id)
{
	AutoLocker<VolumeMap> _(fVolumes);
	ClientVolume* volume = fVolumes->Get(id);
	if (!volume || volume->IsRemoved())
		return NULL;
	volume->AcquireReference();
	return volume;
}

// _PutVolume
//
// The VolumeManager may be locked, but no other lock must be held.
void
ClientConnection::_PutVolume(ClientVolume* volume)
{
	if (!volume)
		return;

	// decrement reference counter and remove the volume, if 0
	AutoLocker<VolumeMap> locker(fVolumes);
	bool removed = (volume->ReleaseReference() == 1 && volume->IsRemoved());
	if (removed)
		fVolumes->Remove(volume->GetID());
	locker.Unlock();

	if (removed) {
		VolumeManagerLocker managerLocker;
		delete volume;
	}
}

// _UnmountVolume
//
// The caller must have a reference to the volume.
void
ClientConnection::_UnmountVolume(ClientVolume* volume)
{
	if (!volume)
		return;
	AutoLocker<VolumeMap> locker(fVolumes);
	volume->MarkRemoved();
	locker.Unlock();

	// push a notification event
	if (VolumeUnmountedEvent* event = new(std::nothrow) VolumeUnmountedEvent) {
		VolumeManagerLocker managerLocker;

		event->opcode = B_DEVICE_UNMOUNTED;
		_PushNodeMonitoringEvent(volume->GetID(), event);
		event->ReleaseReference();
	}
}

// _UnmountAllVolumes
void
ClientConnection::_UnmountAllVolumes()
{
	while (true) {
		// To avoid heap allocation (which can fail) we unmount the volumes
		// chunkwise.
		// get the volumes
		const int32 volumeChunkSize = 32;
		ClientVolume* volumes[volumeChunkSize];
		int32 volumeCount = 0;
		AutoLocker<VolumeMap> volumesLocker(fVolumes);
		for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
			if (ClientVolume* volume = _GetVolume(it.Next().value->GetID())) {
				volumes[volumeCount++] = volume;
			}
			if (volumeCount == volumeChunkSize)
				break;
		}
		volumesLocker.Unlock();

		// unmount and put the volumes
		for (int32 i = 0; i < volumeCount; i++) {
			ClientVolume* volume = volumes[i];
			_UnmountVolume(volume);
			_PutVolume(volume);
		}

		if (volumeCount < volumeChunkSize)
			break;
	}
}

// _NodeMonitoringProcessorEntry
int32
ClientConnection::_NodeMonitoringProcessorEntry(void* data)
{
	return ((ClientConnection*)data)->_NodeMonitoringProcessor();
}


// _NodeMonitoringProcessor
int32
ClientConnection::_NodeMonitoringProcessor()
{
	while (!fClosed) {
		// get the next request
		NodeMonitoringRequest* request = NULL;
		status_t error = fNodeMonitoringEvents->Pop(&request);

		// get a client connection reference
		ConnectionReference connectionReference(this);
		if (!connectionReference.IsValid())
			return B_OK;

		// No request? Next round...
		if (error != B_OK)
			continue;
		ObjectDeleter<NodeMonitoringRequest> requestDeleter(request);

		// send the request
		error = fConnection->SendRequest(request);
		if (error != B_OK) {
			ERROR(("ClientConnection::_NodeMonitoringProcessor(): "
				"Failed to send request.\n"));
		}
	}
	return 0;
}


// _PushNodeMonitoringEvent
//
// The caller must have a connection reference. Moreover the VolumeManager
// must be locked.
status_t
ClientConnection::_PushNodeMonitoringEvent(int32 volumeID,
	NodeMonitoringEvent* event)
{
	if (!event)
		return B_BAD_VALUE;

	// get the volume
	ClientVolume* volume = _GetVolume(volumeID);
	if (!volume && event->opcode != B_DEVICE_UNMOUNTED)
		return B_BAD_VALUE;
	ClientVolumePutter volumePutter(this, volume);

	// create a node monitoring request
	NodeMonitoringRequest* request = NULL;
	status_t error = B_ERROR;
	switch (event->opcode) {
		case B_ENTRY_CREATED:
			error = _EntryCreated(volume,
				dynamic_cast<EntryCreatedEvent*>(event), request);
			break;
		case B_ENTRY_REMOVED:
			error = _EntryRemoved(volume,
				dynamic_cast<EntryRemovedEvent*>(event), request);
			break;
		case B_ENTRY_MOVED:
			error = _EntryMoved(volume,
				dynamic_cast<EntryMovedEvent*>(event), request);
			break;
		case B_STAT_CHANGED:
			error = _NodeStatChanged(volume,
				dynamic_cast<StatChangedEvent*>(event), request);
			break;
		case B_ATTR_CHANGED:
			error = _NodeAttributeChanged(volume,
				dynamic_cast<AttributeChangedEvent*>(event), request);
			break;
		case B_DEVICE_UNMOUNTED:
			error = B_OK;
			break;
	}

	// replace all data buffers -- when the request is actually sent, they
	// might no longer exist
	if (error == B_OK)
		error = RequestBufferReplacer().ReplaceBuffer(request);

	if (error == B_OK) {
		// common initialization
		request->volumeID = volumeID;
		request->opcode = event->opcode;
		request->revision = VolumeManager::GetDefault()->GetRevision();

		// push the request
		error = fNodeMonitoringEvents->Push(request);
		if (error != B_OK)
			delete request;
	}

	return error;
}

// _EntryCreated
status_t
ClientConnection::_EntryCreated(ClientVolume* volume, EntryCreatedEvent* event,
	NodeMonitoringRequest*& _request)
{
	// allocate the request
	EntryCreatedRequest* request = new(std::nothrow) EntryCreatedRequest;
	if (!request)
		return B_NO_MEMORY;
	ObjectDeleter<NodeMonitoringRequest> requestDeleter(request);

	// get the name
	const char* name = event->name.GetString();

	// set the request fields
	request->directoryID = NodeID(event->volumeID, event->directoryID);
	request->nodeID = NodeID(event->volumeID, event->nodeID);
	request->name.SetTo(name);
	if (event->queryHandler) {
		request->port = event->remotePort;
		request->token = event->remoteToken;
		request->queryUpdate = true;
	} else
		request->queryUpdate = false;

	// try to get an entry info
	Entry* entry;
	if (VolumeManager::GetDefault()->LoadEntry(event->volumeID,
			event->directoryID, name, true, &entry) == B_OK
		&& entry->GetNode()->GetVolumeID() == event->volumeID
		&& entry->GetNode()->GetID() == event->nodeID) {
		_GetEntryInfo(entry, &request->entryInfo);
		request->entryInfoValid = true;
	} else
		request->entryInfoValid = false;

	requestDeleter.Detach();
	_request = request;
	return B_OK;
}

// _EntryRemoved
status_t
ClientConnection::_EntryRemoved(ClientVolume* volume, EntryRemovedEvent* event,
	NodeMonitoringRequest*& _request)
{
	// special handling, if it is the root node of the client volume that has
	// been removed
	if (!event->queryHandler
		&& NodeRef(event->nodeVolumeID, event->nodeID)
			== volume->GetRootNodeRef()) {
		NoAllocEntryRef ref(event->nodeVolumeID, event->nodeID, ".");
		BEntry entry;
		if (FDManager::SetEntry(&entry, &ref) != B_OK || !entry.Exists())
			_UnmountVolume(volume);

		// don't send the "entry removed" event
		return B_ERROR;
	}

	// allocate the request
	EntryRemovedRequest* request = new(std::nothrow) EntryRemovedRequest;
	if (!request)
		return B_NO_MEMORY;
	ObjectDeleter<NodeMonitoringRequest> requestDeleter(request);

	// get the name
	const char* name = event->name.GetString();

	// set the request fields
	request->directoryID = NodeID(event->volumeID, event->directoryID);
	request->nodeID = NodeID(event->nodeVolumeID, event->nodeID);
	request->name.SetTo(name);
	if (event->queryHandler) {
		request->port = event->remotePort;
		request->token = event->remoteToken;
		request->queryUpdate = true;
	} else
		request->queryUpdate = false;

	requestDeleter.Detach();
	_request = request;
	return B_OK;
}

// _EntryMoved
status_t
ClientConnection::_EntryMoved(ClientVolume* volume, EntryMovedEvent* event,
	NodeMonitoringRequest*& _request)
{
	// allocate the request
	EntryMovedRequest* request = new(std::nothrow) EntryMovedRequest;
	if (!request)
		return B_NO_MEMORY;
	ObjectDeleter<NodeMonitoringRequest> requestDeleter(request);

	// allocate memory for the names
	int32 fromNameLen = event->fromName.GetLength();
	const char* fromName
		= (fromNameLen > 0 ? event->fromName.GetString() : NULL);
	const char* toName = event->toName.GetString();

	// set the request fields
	request->fromDirectoryID = NodeID(event->volumeID, event->fromDirectoryID);
	request->toDirectoryID = NodeID(event->volumeID, event->toDirectoryID);
	request->nodeID = NodeID(event->nodeVolumeID, event->nodeID);
	request->fromName.SetTo(fromName);
	request->toName.SetTo(toName);
	request->queryUpdate = false;

	// try to get an entry info
	Entry* entry;
	if (VolumeManager::GetDefault()->LoadEntry(event->volumeID,
			event->toDirectoryID, toName, true, &entry) == B_OK
		&& entry->GetNode()->GetVolumeID() == event->nodeVolumeID
		&& entry->GetNode()->GetID() == event->nodeID) {
		_GetEntryInfo(entry, &request->entryInfo);
		request->entryInfoValid = true;
	} else
		request->entryInfoValid = false;

	requestDeleter.Detach();
	_request = request;
	return B_OK;
}

// _NodeStatChanged
status_t
ClientConnection::_NodeStatChanged(ClientVolume* volume,
	StatChangedEvent* event, NodeMonitoringRequest*& _request)
{
	// get the node
	Node* node = volume->GetNode(event->volumeID, event->nodeID);
	if (!node)
		return B_ENTRY_NOT_FOUND;

	// allocate the request
	StatChangedRequest* request = new(std::nothrow) StatChangedRequest;
	if (!request)
		return B_NO_MEMORY;
	ObjectDeleter<NodeMonitoringRequest> requestDeleter(request);

	// set the request fields
	request->nodeID = NodeID(event->volumeID, event->nodeID);
	_GetNodeInfo(node, &request->nodeInfo);
	request->queryUpdate = false;

	requestDeleter.Detach();
	_request = request;
	return B_OK;
}

// _NodeAttributeChanged
status_t
ClientConnection::_NodeAttributeChanged(ClientVolume* volume,
	AttributeChangedEvent* event, NodeMonitoringRequest*& _request)
{
	// get the node
	Node* node = volume->GetNode(event->volumeID, event->nodeID);
	if (!node)
		return B_ENTRY_NOT_FOUND;

	// update the attribute directory
	bool removed = false;
	bool valid = false;
	attr_info info;
	const void* data = NULL;
	status_t error = node->UpdateAttribute(event->attribute.GetString(),
		&removed, &info, &data);
	valid = (error == B_OK);

	// allocate the request
	AttributeChangedRequest* request = new(std::nothrow) AttributeChangedRequest;
	if (!request)
		return B_NO_MEMORY;
	ObjectDeleter<NodeMonitoringRequest> requestDeleter(request);

	// get an attr dir info, if the directory is valid
	if (node->IsAttrDirValid()) {
		status_t error = _GetAttrDirInfo(request, node, &request->attrDirInfo);
		if (error != B_OK)
			return error;
	}

	// get name and the data size
	int32 dataSize = (data ? info.size : 0);
	const char* name = event->attribute.GetString();

	// set the request fields
	request->nodeID = NodeID(event->volumeID, event->nodeID);
	request->attrInfo.name.SetTo(name);
	request->valid = valid;
	request->removed = removed;
	if (!removed && valid) {
		request->attrInfo.info = info;
		request->attrInfo.data.SetTo(data, dataSize);
	}
	request->queryUpdate = false;

	requestDeleter.Detach();
	_request = request;
	return B_OK;
}

// _KnownAttributeType
bool
ClientConnection::_KnownAttributeType(type_code type)
{
	if (!fInverseClientEndianess)
		return false;

	switch (type) {
		case B_BOOL_TYPE:
		case B_CHAR_TYPE:
		case B_COLOR_8_BIT_TYPE:
		case B_DOUBLE_TYPE:
		case B_FLOAT_TYPE:
		case B_GRAYSCALE_8_BIT_TYPE:
		case B_INT64_TYPE:
		case B_INT32_TYPE:
		case B_INT16_TYPE:
		case B_INT8_TYPE:
		case B_MESSAGE_TYPE:
		case B_MESSENGER_TYPE:
		case B_MIME_TYPE:
		case B_MONOCHROME_1_BIT_TYPE:
		case B_OFF_T_TYPE:
		case B_POINTER_TYPE:
		case B_POINT_TYPE:
		case B_RECT_TYPE:
		case B_REF_TYPE:
		case B_RGB_COLOR_TYPE:
		case B_SIZE_T_TYPE:
		case B_SSIZE_T_TYPE:
		case B_STRING_TYPE:
		case B_TIME_TYPE:
		case B_UINT64_TYPE:
		case B_UINT32_TYPE:
		case B_UINT16_TYPE:
		case B_UINT8_TYPE:
		case B_ASCII_TYPE:
		case B_MIME_STRING_TYPE:
			return true;

		//B_RGB_32_BIT_TYPE: We could translate it, but it's heavy...
	}

	return false;
}

// _ConvertAttribute
void
ClientConnection::_ConvertAttribute(const attr_info& info, void* buffer)
{
	swap_data(info.type, buffer, info.size, B_SWAP_ALWAYS);
}


// #pragma mark -

// _OpenQuery
status_t
ClientConnection::_OpenQuery(const char* queryString, uint32 flags,
	port_id remotePort, int32 remoteToken, QueryHandle** _handle)
{
	if (!queryString || !_handle)
		return B_BAD_VALUE;

	// open query
	QueryHandle* queryHandle;
	status_t error = VolumeManager::GetDefault()->OpenQuery(this, queryString,
		flags, remotePort, remoteToken, &queryHandle);
	if (error != B_OK)
		return error;
	BReference<QueryHandle> handleReference(queryHandle, true);

	// lock the handle
	queryHandle->Lock();

	// add the handle
	error = fQueryHandles->AddNodeHandle(queryHandle);
	if (error != B_OK)
		return error;

	handleReference.Detach();
	*_handle = queryHandle;
	return B_OK;
}

// _CloseQuery
status_t
ClientConnection::_CloseQuery(QueryHandle* handle)
{
	if (!handle || !fQueryHandles->RemoveNodeHandle(handle))
		return B_BAD_VALUE;

	return B_OK;
}

// _LockQueryHandle
//
// VolumeManager must NOT be locked.
status_t
ClientConnection::_LockQueryHandle(int32 cookie, QueryHandle** _handle)
{
	NodeHandle* handle;
	status_t error = fQueryHandles->LockNodeHandle(cookie, &handle);
	if (error == B_OK)
		*_handle = static_cast<QueryHandle*>(handle);
	return error;
}

// _UnlockQueryHandle
//
// VolumeManager may or may not be locked.
void
ClientConnection::_UnlockQueryHandle(NodeHandle* nodeHandle)
{
	fQueryHandles->UnlockNodeHandle(nodeHandle);
}


// #pragma mark -

// _GetAllClientVolumeIDs
int32
ClientConnection::_GetAllClientVolumeIDs(int32* volumeIDs, int32 arraySize,
	ClientVolumeFilter* filter)
{
	int32 count = 0;
	AutoLocker<VolumeMap> volumesLocker(fVolumes);
	for (VolumeMap::Iterator it = fVolumes->GetIterator();
		 it.HasNext() && arraySize > count;) {
		ClientVolume* clientVolume = it.Next().value;
		if (!filter || filter->FilterVolume(this, clientVolume))
			volumeIDs[count++] = clientVolume->GetID();
	}

	return count;
}

// _GetContainingClientVolumes
int32
ClientConnection::_GetContainingClientVolumes(Directory* directory,
	int32* volumeIDs, int32 arraySize, ClientVolumeFilter* filter)
{
	int32 count = 0;
	VolumeManager* volumeManager = VolumeManager::GetDefault();
	AutoLocker<VolumeMap> volumesLocker(fVolumes);
	for (VolumeMap::Iterator it = fVolumes->GetIterator();
		 it.HasNext() && arraySize > count;) {
		ClientVolume* clientVolume = it.Next().value;
		Directory* clientVolumeRoot = clientVolume->GetRootDirectory();
		if (volumeManager->DirectoryContains(clientVolumeRoot, directory, true)
			&& (!filter || filter->FilterVolume(this, clientVolume))) {
			volumeIDs[count++] = clientVolume->GetID();
		}
	}

	return count;
}


// #pragma mark -
// #pragma mark ----- ClientConnectionListener -----

// constructor
ClientConnectionListener::ClientConnectionListener()
{
}

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