path: root/src/shared/networkmessage.cpp

/*
 * NetworkMessage.cpp
 *
 *  Created on: 18.01.2013
 *      Author: sr
 */

#include <QtCore>
#include <QtNetwork>
#include "networkmessage.h"

#define HEADER_LEN 8
#define MAX_MSG_LEN 60000

#define BYTE_SWAP4(x) \
    ((((x) & 0xFF000000u) >> 24) | \
     (((x) & 0x00FF0000u) >> 8)  | \
     (((x) & 0x0000FF00u) << 8)  | \
     (((x) & 0x000000FFu) << 24))

#define BYTE_SWAP2(x) \
    ((((x) & 0xFF00u) >> 8) | \
     (((x) & 0x00FFu) << 8))

static quint16 _htons(const quint16 x)
{
	if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
		return x;
	return quint16(BYTE_SWAP2(x));
}

static quint32 _htonl(const quint32 x)
{
	if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
		return x;
	return quint32(BYTE_SWAP4(x));
}

static quint16 _ntohs(const char *in)
{
	return quint16(quint8(in[0]) << 8
			| quint8(in[1]));
}

static quint32 _ntohl(const char *in)
{
	return quint32(quint8(in[0])) << 24
			| quint32(quint8(in[1])) << 16
			| quint32(quint8(in[2])) << 8
			| quint32(quint8(in[3]));
}

/*
 // ####################################################### \\ ° . °
 \\ ####################################################### // \___/
 */

NetworkMessage::NetworkMessage() :
	_buffer(nullptr), _bufferSize(0), _bufferPos(0), _lastBufferSize(0), _mode(0)
{
	//
}

NetworkMessage::~NetworkMessage()
{
	if (_buffer)
		delete[] _buffer;
}

inline void NetworkMessage::allocBuffer()
{
	if (_lastBufferSize < _bufferSize || _buffer == nullptr) {
		if (_buffer)
			delete[] _buffer;
		_lastBufferSize = _bufferSize;
		_buffer = new char[_lastBufferSize];
	}
}

int NetworkMessage::readMessage(QAbstractSocket* socket)
{
	// Check/Set the _mode variable, so read and write calls are not mixed
	if (_mode != 1) {
		if (_mode != 0) {
			qDebug("NetworkMessage::readMessage(TCP) called when class was in mode %d!", _mode);
			return NM_READ_FAILED;
		}
		_mode = 1;
	}
	// buffer size == 0 means the header hasn't been received yet. do so and set things up
	if (_bufferSize == 0) {
		if (socket->bytesAvailable() < HEADER_LEN)
			return NM_READ_INCOMPLETE;
		char header[HEADER_LEN];
		if (socket->read(header, HEADER_LEN) != HEADER_LEN) {
			qDebug("FIXME: Socket said 8 bytes available, but could not read 8...");
			return NM_READ_FAILED;
		}
		if (!this->parseHeader(header))
			return NM_READ_FAILED;
		//qDebug() << "Expecting message of " << _bufferSize << " bytes";
		allocBuffer();
	}
	if (_bufferSize > _bufferPos) {
		while (_bufferSize > _bufferPos && socket->bytesAvailable() > 0) {
			const qint64 ret = socket->read(_buffer + _bufferPos, _bufferSize - _bufferPos);
			//qDebug() << "Read " << ret << " bytes";
			if (ret < 0 || ret > (_bufferSize - _bufferPos)) {
				qDebug("Socket read failed (TCP), return code %d", int(ret));
				return NM_READ_FAILED;
			}
			_bufferPos += quint32(ret);
			//qDebug() << "Buffer has now " << _bufferPos << " of " << _bufferSize << " bytes";
		}
		if (_bufferSize == _bufferPos) {
			if (!this->parseMessage(_buffer))
				return NM_READ_FAILED;
		}
	}
	return NM_READ_OK;
}

int NetworkMessage::readMessage(char* data, quint32 len)
{
	// Check/Set the _mode variable, so read and write calls are not mixed
	if (_mode != 1) {
		if (_mode != 0) {
			qDebug("NetworkMessage::readMessage(UDP) called when class was in mode %d!", _mode);
			return NM_READ_FAILED;
		}
		_mode = 1;
	}
	if (len < HEADER_LEN) {
		qDebug("UDP message shorter than 8 bytes. ignored.");
		return NM_READ_FAILED;
	}
	if (!this->parseHeader(data))
		return NM_READ_FAILED;
	if (len != _bufferSize + HEADER_LEN) {
		qDebug("UDP packet has wrong size. Is %d, expected %d", int(_bufferSize), len - HEADER_LEN);
		return NM_READ_FAILED;
	}
	return this->parseMessage(data + HEADER_LEN) ? NM_READ_OK : NM_READ_FAILED;
}

bool NetworkMessage::parseHeader(char *header)
{
	if (header[0] != 'P' || header[1] != 'V' || header[2] != 'S' || header[3] != '2') {
		qDebug("Protocol magic wrong.");
		return false;
	}
	_bufferPos = 0;
	_bufferSize = _ntohl(header + 4);
	if (_bufferSize > MAX_MSG_LEN) {
		qDebug("Disconnecting Client: MAX_MSG_LEN exceeded.");
		return false;
	}
	if (_bufferSize < 4) { // TODO: magic number. msg needs to be at least 4 bytes for 1 key/value pair of length 0 each.
		qDebug("A Client sent an empty message.");
		return false;
	}
	return true;
}

bool NetworkMessage::parseMessage(char *buffer)
{
	char *ptr = buffer;
	while (_bufferSize - (ptr - buffer) >= 4) {
		const quint16 keyLen = _ntohs(ptr);
		ptr += 2;
		const quint16 valLen = _ntohs(ptr);
		ptr += 2;
		if (_bufferSize - (ptr - buffer) < keyLen + valLen) {
			qDebug() << "Warning: Error parsing message. key(" << keyLen << ")+value(" << valLen
			         << ") length > total remaining bytes (" << (_bufferSize - (ptr - buffer)) << ")";
			return false;
		}
		_fields.insert(QByteArray(ptr, keyLen), QByteArray(ptr + keyLen, valLen));
		//qDebug() << "Got " << QString::fromUtf8(ptr, keyLen) << " -> " << QString::fromUtf8(ptr + keyLen, valLen);
		ptr += keyLen + valLen;
	}
	_mode = 3;
	return true;
}

bool NetworkMessage::writeMessage(QAbstractSocket * const socket)
{
	if (_mode != 2) {
		if (_mode == 1) {
			qDebug("NetworkMessage::writeMessage called when class was in mode %d!", _mode);
			return false;
		}
		_mode = 1;
		_bufferPos = 0;
	}
	// key/value pairs have not been serialized yet...
	if (_bufferSize == 0) {
		this->serializeMessage();
	}
	const qint64 ret = socket->write(_buffer + _bufferPos, _bufferSize - _bufferPos);
	if (ret == 0)
		return true;
	if (ret < 0 || ret > (_bufferSize - _bufferPos))
		return false;
	_bufferPos += quint32(ret);
	if (_bufferPos == _bufferSize) {
		_bufferPos = 0;
		_mode = 4;
	}
	return true;
}

bool NetworkMessage::writeMessage(QUdpSocket* socket, const QHostAddress& address, quint16 port)
{
	if (_mode != 4) {
		if (_mode == 1) {
			qDebug("NetworkMessage::writeMessage called when class was in mode %d!", _mode);
			return false;
		}
		_mode = 4;
		_bufferPos = 0;
	}
	// key/value pairs have not been serialized yet...
	if (_bufferSize == 0) {
		this->serializeMessage();
	}
	const qint64 ret = socket->writeDatagram(_buffer, _bufferSize, address, port);
	if (ret != _bufferSize)
		return false;
	if (ret < 0)
		return false;
	_bufferPos = 0;
	return true;
}

void NetworkMessage::serializeMessage()
{
	QByteArray buf;
	//qDebug() << "Default size: " << buf.capacity();
	buf.reserve(_lastBufferSize > 0 ? int(_lastBufferSize) : 200);
	for (QHash<QByteArray, QByteArray>::const_iterator it = _fields.begin(); it != _fields.end(); ++it) {
		const QByteArray &ba = it.key();
		const QByteArray &val = it.value();
		quint16 keyLen = _htons(quint16(ba.size()));
		quint16 valLen = _htons(quint16(val.size()));
		//qDebug() << "Adding to msg(" << ba.size() << "/" << val.size() << "): " << ba << " -> " << val;
		buf.append(reinterpret_cast<const char*>(&keyLen), 2);
		buf.append(reinterpret_cast<const char*>(&valLen), 2);
		buf.append(ba);
		buf.append(val);
	}
	_bufferSize = quint32(buf.length() + HEADER_LEN);
	allocBuffer();
	memcpy(_buffer + HEADER_LEN, buf.data(), size_t(buf.size()));
	_buffer[0] = 'P';
	_buffer[1] = 'V';
	_buffer[2] = 'S';
	_buffer[3] = '2';
	const quint32 flipped = _htonl(_bufferSize - HEADER_LEN);
	memcpy(_buffer + 4, &flipped, 4);
}

void NetworkMessage::buildErrorMessage(const QString& error)
{
	this->reset();
	this->setField(_ID, _ERROR);
	this->setField(_ERROR, error);
}