haiku.git

// ServerVolume.cpp

#include "ServerVolume.h"

#include <new>

#include <AutoDeleter.h>
#include <AutoLocker.h>

#include "Compatibility.h"
#include "DebugSupport.h"
#include "ExtendedServerInfo.h"
#include "QueryManager.h"
#include "SendReceiveRequest.h"
#include "ServerConnection.h"
#include "ServerConnectionProvider.h"
#include "ServerQueryIterator.h"
#include "ShareVolume.h"
#include "VolumeEvent.h"
#include "VolumeManager.h"
#include "VolumeSupport.h"

// constructor
ServerVolume::ServerVolume(VolumeManager* volumeManager,
	ExtendedServerInfo* serverInfo)
	: VirtualVolume(volumeManager),
	  fServerInfo(serverInfo),
	  fConnectionProvider(NULL)
{
	fServerInfo->AcquireReference();
}

// destructor
ServerVolume::~ServerVolume()
{
	if (fConnectionProvider)
		fConnectionProvider->ReleaseReference();
	if (fServerInfo)
		fServerInfo->ReleaseReference();
}

// GetServerAddress
NetAddress
ServerVolume::GetServerAddress()
{
	AutoLocker<Locker> _(fLock);
	return fServerInfo->GetAddress();
}

// SetServerInfo
void
ServerVolume::SetServerInfo(ExtendedServerInfo* serverInfo)
{
	if (!serverInfo)
		return;

	// set the new info
	fLock.Lock();
	fServerInfo->ReleaseReference();
	fServerInfo = serverInfo;
	fServerInfo->AcquireReference();
	BReference<ExtendedServerInfo> newReference(fServerInfo);

	// remove shares, that are no longer there

	// init a directory iterator
	VirtualDirIterator iterator;
	iterator.SetDirectory(fRootNode, true);

	// iterate through the directory
	const char* name;
	Node* node;
	while (iterator.GetCurrentEntry(&name, &node)) {
		iterator.NextEntry();
		// TODO: Searching by name is currently O(n).
		bool remove = (!serverInfo->GetShareInfo(name));
		fLock.Unlock();

		if (remove) {
			PRINT("  removing share: %s\n", name);
			if (Volume* volume = GetChildVolume(name)) {
				volume->SetUnmounting(true);
				volume->PutVolume();
			}
		}

		fLock.Lock();
	}

	// uninit the directory iterator
	iterator.SetDirectory(NULL);
	fLock.Unlock();

	// add new shares
	int32 count = serverInfo->CountShares();
	for (int32 i = 0; i < count; i++) {
		ExtendedShareInfo* shareInfo = serverInfo->ShareInfoAt(i);
		const char* shareName = shareInfo->GetShareName();

		Volume* volume = GetChildVolume(shareName);
		if (volume) {
			volume->PutVolume();
		} else {
			PRINT("  adding share: %s\n",
				shareInfo->GetShareName());
			status_t error = _AddShare(shareInfo);
			if (error != B_OK) {
				ERROR("ServerVolume::SetServerInfo(): ERROR: Failed to add "
					"share `%s': %s\n", shareName, strerror(error));
			}
		}
	}
}

// Init
status_t
ServerVolume::Init(const char* name)
{
	status_t error = VirtualVolume::Init(name);
	if (error != B_OK)
		return error;

	// create the server connection provider
	fConnectionProvider = new ServerConnectionProvider(fVolumeManager,
		fServerInfo, GetRootID());
	if (!fConnectionProvider) {
		Uninit();
		return B_NO_MEMORY;
	}
	error = fConnectionProvider->Init();
	if (error != B_OK) {
		Uninit();
		return error;
	}

	// add share volumes
	int32 count = fServerInfo->CountShares();
	for (int32 i = 0; i < count; i++) {
		ExtendedShareInfo* shareInfo = fServerInfo->ShareInfoAt(i);

		error = _AddShare(shareInfo);
		if (error != B_OK) {
			ERROR("ServerVolume::Init(): ERROR: Failed to add share `%s': "
				"%s\n", shareInfo->GetShareName(), strerror(error));
		}
	}

	return B_OK;
}

// Uninit
void
ServerVolume::Uninit()
{
	if (fConnectionProvider)
		fConnectionProvider->CloseServerConnection();

	VirtualVolume::Uninit();
}

// PrepareToUnmount
void
ServerVolume::PrepareToUnmount()
{
	VirtualVolume::PrepareToUnmount();
}

// HandleEvent
void
ServerVolume::HandleEvent(VolumeEvent* event)
{
	if (event->GetType() == CONNECTION_BROKEN_EVENT) {
		// tell all share volumes that they have been disconnected

		// init a directory iterator
		fLock.Lock();
		VirtualDirIterator iterator;
		iterator.SetDirectory(fRootNode, true);

		// iterate through the directory
		const char* name;
		Node* node;
		while (iterator.GetCurrentEntry(&name, &node)) {
			iterator.NextEntry();
			Volume* volume = fVolumeManager->GetVolume(node->GetID());
			fLock.Unlock();
			if (ShareVolume* shareVolume = dynamic_cast<ShareVolume*>(volume))
				shareVolume->ConnectionClosed();
			if (volume)
				volume->PutVolume();
			fLock.Lock();
		}

		// uninit the directory iterator
		iterator.SetDirectory(NULL);

		// mark ourselves unmounting
		SetUnmounting(true);
		fLock.Unlock();
	}
}


// #pragma mark -
// #pragma mark ----- FS -----

// Unmount
status_t
ServerVolume::Unmount()
{
	return B_OK;
}


// #pragma mark -
// #pragma mark ----- queries -----

// OpenQuery
status_t
ServerVolume::OpenQuery(const char* queryString, uint32 flags, port_id port,
	int32 token, QueryIterator** _iterator)
{
// TODO: Do nothing when there are no (mounted) shares.
	// get connection
	ServerConnection* serverConnection
		= fConnectionProvider->GetExistingServerConnection();
	if (!serverConnection)
		return ERROR_NOT_CONNECTED;
	RequestConnection* connection = serverConnection->GetRequestConnection();

	// create a query iterator and add it to the query manager
	ServerQueryIterator* iterator = new(std::nothrow) ServerQueryIterator(this);
	if (!iterator)
		return B_NO_MEMORY;
	QueryManager* queryManager = fVolumeManager->GetQueryManager();
	status_t error = queryManager->AddIterator(iterator);
	if (error != B_OK) {
		delete iterator;
		return error;
	}
	QueryIteratorPutter iteratorPutter(queryManager, iterator);

	// prepare the request
	OpenQueryRequest request;
	request.queryString.SetTo(queryString);
	request.flags = flags;
	request.port = port;
	request.token = token;

	// send the request
	OpenQueryReply* reply;
	error = SendRequest(connection, &request, &reply);
	if (error != B_OK)
		RETURN_ERROR(error);
	ObjectDeleter<Request> replyDeleter(reply);
	if (reply->error != B_OK)
		RETURN_ERROR(reply->error);

	// set the result
	iterator->SetRemoteCookie(reply->cookie);
	*_iterator = iterator;
	iteratorPutter.Detach();
	return B_OK;
}

// FreeQueryIterator
void
ServerVolume::FreeQueryIterator(QueryIterator* _iterator)
{
	ServerQueryIterator* iterator
		= dynamic_cast<ServerQueryIterator*>(_iterator);

	int32 cookie = iterator->GetRemoteCookie();
	if (cookie >= 0) {
		// prepare the close request
		CloseRequest request;
		request.volumeID = -1;
		request.cookie = cookie;

		// send the request
		ServerConnection* serverConnection
			= fConnectionProvider->GetExistingServerConnection();
		if (serverConnection && serverConnection->IsConnected()) {
			CloseReply* reply;
			status_t error = SendRequest(
				serverConnection->GetRequestConnection(), &request, &reply);
			if (error == B_OK)
				delete reply;
		}
	}

	delete iterator;
}

// ReadQuery
status_t
ServerVolume::ReadQuery(QueryIterator* _iterator, struct dirent* buffer,
	size_t bufferSize, int32 count, int32* countRead)
{
	// get connection
	ServerConnection* serverConnection
		= fConnectionProvider->GetExistingServerConnection();
	if (!serverConnection)
		return ERROR_NOT_CONNECTED;
	RequestConnection* connection = serverConnection->GetRequestConnection();

	ServerQueryIterator* iterator
		= dynamic_cast<ServerQueryIterator*>(_iterator);

	*countRead = 0;

	for (;;) {
		// if the iterator hasn't cached any more share volume IDs, we need to
		// ask the server for the next entry
		if (!iterator->HasNextShareVolumeID()) {
			// prepare the request
			ReadQueryRequest request;
			request.cookie = iterator->GetRemoteCookie();
			request.count = 1;

			// send the request
			ReadQueryReply* reply;
			status_t error = SendRequest(connection, &request, &reply);
			if (error != B_OK)
				RETURN_ERROR(error);
			ObjectDeleter<Request> replyDeleter(reply);
			if (reply->error != B_OK)
				RETURN_ERROR(reply->error);

			// check, if anything has been read at all
			if (reply->count == 0) {
				*countRead = 0;
				return B_OK;
			}

			// update the iterator
			error = iterator->SetEntry(reply->clientVolumeIDs.GetElements(),
				reply->clientVolumeIDs.CountElements(), reply->dirInfo,
				reply->entryInfo);
			if (error != B_OK)
				return error;
		}

		// get the next concerned share volume and delegate the rest of the work
		int32 volumeID = iterator->NextShareVolumeID();
		ShareVolume* shareVolume = _GetShareVolume(volumeID);
		if (!shareVolume)
			continue;
		VolumePutter volumePutter(shareVolume);

		return shareVolume->GetQueryEntry(iterator->GetEntryInfo(),
			iterator->GetDirectoryInfo(), buffer, bufferSize, countRead);
	}
}


// #pragma mark -
// #pragma mark ----- private -----

// _AddShare
status_t
ServerVolume::_AddShare(ExtendedShareInfo* shareInfo)
{
	// create the share volume
	ShareVolume* shareVolume = new(std::nothrow) ShareVolume(fVolumeManager,
		fConnectionProvider, fServerInfo, shareInfo);
	if (!shareVolume)
		return B_NO_MEMORY;
	status_t error = shareVolume->Init(shareInfo->GetShareName());
	if (error != B_OK) {
		delete shareVolume;
		return error;
	}

	// add the volume to the volume manager
	error = fVolumeManager->AddVolume(shareVolume);
	if (error != B_OK) {
		delete shareVolume;
		return error;
	}
	VolumePutter volumePutter(shareVolume);

	// add the volume to us
	error = AddChildVolume(shareVolume);
	if (error != B_OK) {
		shareVolume->SetUnmounting(true);
		return error;
	}

	return B_OK;
}

// _GetShareVolume
ShareVolume*
ServerVolume::_GetShareVolume(int32 volumeID)
{
	AutoLocker<Locker> locker(fLock);
	VirtualDirIterator dirIterator;
	dirIterator.SetDirectory(fRootNode, true);

	// iterate through the directory
	const char* name;
	Node* node;
	while (dirIterator.GetCurrentEntry(&name, &node)) {
		Volume* volume = fVolumeManager->GetVolume(node->GetID());
		ShareVolume* shareVolume = dynamic_cast<ShareVolume*>(volume);
		if (shareVolume && shareVolume->GetID() == volumeID)
			return shareVolume;

		volume->PutVolume();
		dirIterator.NextEntry();
	}

	return NULL;
}