haiku.git

// PortChannel.cpp

#include <new>
#include <string.h>

#include "PortChannel.h"
#include "Utils.h"

static const int32 kMaxPortMessageSize = 102400;	// 100 KB
static const int32 kDefaultBufferSize	= 10240;	// 10 KB

// constructor
PortChannel::PortChannel()
	: Channel(),
	  fSendPort(-1),
	  fReceivePort(-1),
	  fBuffer(new(std::nothrow) uint8[kDefaultBufferSize]),
	  fBufferSize(kDefaultBufferSize),
	  fBufferOffset(0),
	  fBufferContentSize(0)
{
	fSendPort = create_port(10, "port connection send port");
	fReceivePort = create_port(10, "port connection receive port");
}

// constructor
PortChannel::PortChannel(const Info* info, bool inverse)
	: Channel(),
	  fSendPort(inverse ? info->receivePort : info->sendPort),
	  fReceivePort(inverse ? info->sendPort : info->receivePort),
	  fBuffer(new(std::nothrow) uint8[kDefaultBufferSize]),
	  fBufferSize(kDefaultBufferSize),
	  fBufferOffset(0),
	  fBufferContentSize(0)
{
}

// constructor
PortChannel::PortChannel(port_id sendPort, port_id receivePort)
	: Channel(),
	  fSendPort(sendPort),
	  fReceivePort(receivePort),
	  fBuffer(new(std::nothrow) uint8[kDefaultBufferSize]),
	  fBufferSize(kDefaultBufferSize),
	  fBufferOffset(0),
	  fBufferContentSize(0)
{
}

// destructor
PortChannel::~PortChannel()
{
	delete[] fBuffer;
}

// InitCheck
status_t
PortChannel::InitCheck() const
{
	if (fSendPort < 0)
		return fSendPort;
	if (fReceivePort < 0)
		return fReceivePort;
	if (!fBuffer)
		return B_NO_MEMORY;
	return B_OK;
}

// GetInfo
void
PortChannel::GetInfo(Info* info) const
{
	if (info) {
		info->sendPort = fSendPort;
		info->receivePort = fReceivePort;
	}
}

// Close
void
PortChannel::Close()
{
	if (fSendPort >= 0) {
		delete_port(fSendPort);
		fSendPort = -1;
	}
	if (fReceivePort >= 0) {
		delete_port(fReceivePort);
		fReceivePort = -1;
	}
}

// Send
status_t
PortChannel::Send(const void* _buffer, int32 size)
{
	if (size == 0)
		return B_OK;
	if (!_buffer || size < 0)
		return B_BAD_VALUE;
	const uint8* buffer = static_cast<const uint8*>(_buffer);
	while (size > 0) {
		int32 sendSize = min(size, fBufferSize);
		status_t error = write_port(fSendPort, 0, buffer, size);
		if (error != B_OK)
			return error;
		size -= sendSize;
		buffer += sendSize;
	}
	return B_OK;
}

// Receive
status_t
PortChannel::Receive(void* _buffer, int32 size)
{
	if (size == 0)
		return B_OK;
	if (!_buffer || size < 0)
		return B_BAD_VALUE;
	uint8* buffer = static_cast<uint8*>(_buffer);
	while (size > 0) {
		if (fBufferContentSize > 0) {
			// there's something in our buffer: just read from there
			int32 bytesRead = min(size, fBufferContentSize);
			memcpy(buffer, fBuffer + fBufferOffset, bytesRead);
			fBufferOffset += bytesRead;
			fBufferContentSize -= bytesRead;
			size -= bytesRead;
			buffer += bytesRead;
		} else {
			// nothing left in the buffer: we read from the port
			if (size > fBufferSize) {
				// we shall read more than what would fit into our buffer, so
				// we can directly read into the user buffer
				ssize_t bytesRead = read_port(fReceivePort, 0, buffer, size);
				if (bytesRead < 0)
					return bytesRead;
				size -= bytesRead;
				buffer += bytesRead;
			} else {
				// we read into our buffer
				ssize_t bytesRead = read_port(fReceivePort, 0, fBuffer,
					fBufferSize);
				if (bytesRead < 0)
					return bytesRead;
				fBufferOffset = 0;
				fBufferContentSize = bytesRead;
			}
		}
	}
	return B_OK;
}