haiku.git

// RequestChannel.cpp

#include "RequestChannel.h"

#include <new>
#include <typeinfo>

#include <stdlib.h>
#include <string.h>

#include <AutoDeleter.h>
#include <ByteOrder.h>

#include "Channel.h"
#include "Compatibility.h"
#include "DebugSupport.h"
#include "Request.h"
#include "RequestDumper.h"
#include "RequestFactory.h"
#include "RequestFlattener.h"
#include "RequestUnflattener.h"

static const int32 kMaxSaneRequestSize	= 128 * 1024;	// 128 KB
static const int32 kDefaultBufferSize	= 4096;			// 4 KB

// ChannelWriter
class RequestChannel::ChannelWriter : public Writer {
public:
	ChannelWriter(Channel* channel, void* buffer, int32 bufferSize)
		: fChannel(channel),
		  fBuffer(buffer),
		  fBufferSize(bufferSize),
		  fBytesWritten(0)
	{
	}

	virtual status_t Write(const void* buffer, int32 size)
	{
		status_t error = B_OK;
		// if the data don't fit into the buffer anymore, flush the buffer
		if (fBytesWritten + size > fBufferSize) {
			error = Flush();
			if (error != B_OK)
				return error;
		}
		// if the data don't even fit into an empty buffer, just send it,
		// otherwise append it to the buffer
		if (size > fBufferSize) {
			error = fChannel->Send(buffer, size);
			if (error != B_OK)
				return error;
		} else {
			memcpy((uint8*)fBuffer + fBytesWritten, buffer, size);
			fBytesWritten += size;
		}
		return error;
	}

	status_t Flush()
	{
		if (fBytesWritten == 0)
			return B_OK;
		status_t error = fChannel->Send(fBuffer, fBytesWritten);
		if (error != B_OK)
			return error;
		fBytesWritten = 0;
		return B_OK;
	}

private:
	Channel*	fChannel;
	void*		fBuffer;
	int32		fBufferSize;
	int32		fBytesWritten;
};


// MemoryReader
class RequestChannel::MemoryReader : public Reader {
public:
	MemoryReader(void* buffer, int32 bufferSize)
		: Reader(),
		  fBuffer(buffer),
		  fBufferSize(bufferSize),
		  fBytesRead(0)
	{
	}

	virtual status_t Read(void* buffer, int32 size)
	{
		// check parameters
		if (!buffer || size < 0)
			return B_BAD_VALUE;
		if (size == 0)
			return B_OK;
		// get pointer into data buffer
		void* localBuffer;
		bool mustFree;
		status_t error = Read(size, &localBuffer, &mustFree);
		if (error != B_OK)
			return error;
		// copy data into supplied buffer
		memcpy(buffer, localBuffer, size);
		return B_OK;
	}

	virtual status_t Read(int32 size, void** buffer, bool* mustFree)
	{
		// check parameters
		if (size < 0 || !buffer || !mustFree)
			return B_BAD_VALUE;
		if (fBytesRead + size > fBufferSize)
			return B_BAD_VALUE;
		// get the data pointer
		*buffer = (uint8*)fBuffer + fBytesRead;
		*mustFree = false;
		fBytesRead += size;
		return B_OK;
	}

	bool AllBytesRead() const
	{
		return (fBytesRead == fBufferSize);
	}

private:
	void*	fBuffer;
	int32	fBufferSize;
	int32	fBytesRead;
};


// RequestHeader
struct RequestChannel::RequestHeader {
	uint32	type;
	int32	size;
};


// constructor
RequestChannel::RequestChannel(Channel* channel)
	: fChannel(channel),
	  fBuffer(NULL),
	  fBufferSize(0)
{
	// allocate the send buffer
	fBuffer = malloc(kDefaultBufferSize);
	if (fBuffer)
		fBufferSize = kDefaultBufferSize;
}

// destructor
RequestChannel::~RequestChannel()
{
	free(fBuffer);
}

// SendRequest
status_t
RequestChannel::SendRequest(Request* request)
{
	if (!request)
		RETURN_ERROR(B_BAD_VALUE);
	PRINT("%p->RequestChannel::SendRequest(): request: %p, type: %s\n", this, request, typeid(*request).name());

	// get request size
	int32 size;
	status_t error = _GetRequestSize(request, &size);
	if (error != B_OK)
		RETURN_ERROR(error);
	if (size < 0 || size > kMaxSaneRequestSize) {
		ERROR("RequestChannel::SendRequest(): ERROR: Invalid request size: "
			"%" B_PRId32 "\n", size);
		RETURN_ERROR(B_BAD_DATA);
	}

	// write the request header
	RequestHeader header;
	header.type = B_HOST_TO_BENDIAN_INT32(request->GetType());
	header.size = B_HOST_TO_BENDIAN_INT32(size);
	ChannelWriter writer(fChannel, fBuffer, fBufferSize);
	error = writer.Write(&header, sizeof(RequestHeader));
	if (error != B_OK)
		RETURN_ERROR(error);

	// now write the request in earnest
	RequestFlattener flattener(&writer);
	request->Flatten(&flattener);
	error = flattener.GetStatus();
	if (error != B_OK)
		RETURN_ERROR(error);
	error = writer.Flush();
	RETURN_ERROR(error);
}

// ReceiveRequest
status_t
RequestChannel::ReceiveRequest(Request** _request)
{
	if (!_request)
		RETURN_ERROR(B_BAD_VALUE);

	// get the request header
	RequestHeader header;
	status_t error = fChannel->Receive(&header, sizeof(RequestHeader));
	if (error != B_OK)
		RETURN_ERROR(error);
	header.type = B_HOST_TO_BENDIAN_INT32(header.type);
	header.size = B_HOST_TO_BENDIAN_INT32(header.size);
	if (header.size < 0 || header.size > kMaxSaneRequestSize) {
		ERROR("RequestChannel::ReceiveRequest(): ERROR: Invalid request size: "
			"%" B_PRId32 "\n", header.size);
		RETURN_ERROR(B_BAD_DATA);
	}

	// create the request
	Request* request;
	error = RequestFactory::CreateRequest(header.type, &request);
	if (error != B_OK)
		RETURN_ERROR(error);
	ObjectDeleter<Request> requestDeleter(request);

	// allocate a buffer for the data and read them
	if (header.size > 0) {
		RequestBuffer* requestBuffer = RequestBuffer::Create(header.size);
		if (!requestBuffer)
			RETURN_ERROR(B_NO_MEMORY);
		request->AttachBuffer(requestBuffer);

		// receive the data
		error = fChannel->Receive(requestBuffer->GetData(), header.size);
		if (error != B_OK)
			RETURN_ERROR(error);

		// unflatten the request
		MemoryReader reader(requestBuffer->GetData(), header.size);
		RequestUnflattener unflattener(&reader);
		request->Unflatten(&unflattener);
		error = unflattener.GetStatus();
		if (error != B_OK)
			RETURN_ERROR(error);
		if (!reader.AllBytesRead())
			RETURN_ERROR(B_BAD_DATA);
	}

	requestDeleter.Detach();
	*_request = request;
	PRINT("%p->RequestChannel::ReceiveRequest(): request: %p, type: %s\n", this, request, typeid(*request).name());
	return B_OK;
}

// _GetRequestSize
status_t
RequestChannel::_GetRequestSize(Request* request, int32* size)
{
	DummyWriter dummyWriter;
	RequestFlattener flattener(&dummyWriter);
	request->ShowAround(&flattener);
	status_t error = flattener.GetStatus();
	if (error != B_OK)
		return error;
	*size = flattener.GetBytesWritten();
	return error;
}