m2.mbcp/src/message.cc

#include <netinet/in.h>

#include "macros.h"
#include "message.h"

#define DEBUG_INPUT		0
#define DEBUG_OUTPUT	0

#define DEBUG	(DEBUG_INPUT || DEBUG_OUTPUT)

Message::Message(const Message & original){
	printf("Message::Message -- copy\n");

	_size = original._size;
	_raw = new char[_size];
	memcpy(_raw, original._raw, _size);

	_data_size = original._data_size;
	_data = new char[_data_size];
	memcpy(_data, original._data, _data_size);

	_type = original._type;

	_stamp = new TimeStamp(*(original._stamp));

}

Message::Message(void * data, int len) {
	_raw = new char[len];
	memcpy(_raw, data, len);
	_size = len;

	if (DEBUG_INPUT) 
		printf("Message::Message(void* , int) -- length %d\n",len);

	int index = 0;
	// découper le type
	_type = (Protocol::Type)(_raw[index]);	
	index += 1;

	_stamp = new TimeStamp(_type, (_raw + index), len - index);
	index += _stamp->getRawSize();

	// initialise message from the following data
	_data_size = -1;
	memcpy(&_data_size, (_raw + index), 2);
	_data_size = ntohs(_data_size);
	index += 2;

	if (DEBUG_INPUT) 
		printf("Message::Message -- message length %d\n", _data_size);

	_data = new char[_data_size];
	memcpy(_data, (_raw+index), _data_size);

//	if (DEBUG_INPUT)	
//		printf("Message::Message -- message data '%s'\n",_data); //FIXME (buffer overflow)
}


Message::Message(Protocol::Type type, TimeStamp &timestamp, char * mesg, unsigned short mesg_size) : 
	_type(type)
{
	_data = new char[mesg_size];
	_data_size = mesg_size;
	strncpy(_data, mesg, _data_size);

	_stamp = new TimeStamp(timestamp);

	if (DEBUG_OUTPUT)
		printf("Message::Message -- constructing from type, stamp, string\n");

	// construire le message qui va bien a partir des parametres
	unsigned char dgram_type;
	unsigned int dgram_size;
	char * dgram_stamp;  
	unsigned int dgram_type_idx;
	unsigned int dgram_stamp_idx;
	unsigned int dgram_messagesize_idx;
	unsigned int dgram_messagedata_idx;

	printf("Message::Message -- initialising\n");

	dgram_type_idx = 0;
	dgram_stamp_idx = 1;

	if (DEBUG_OUTPUT)
		printf("Message::Message -- computing message length\n");

	dgram_messagesize_idx = dgram_stamp_idx + _stamp->getRawSize();

	if (DEBUG_OUTPUT)
		printf("Message::Message -- computing message length %d\n",dgram_messagesize_idx);

	dgram_messagedata_idx = dgram_messagesize_idx + 2;	

	if (DEBUG_OUTPUT)
		printf("Message::Message -- computing message length %d\n",dgram_messagedata_idx);

	dgram_size = dgram_messagedata_idx + _data_size;
	_size = dgram_size;

	if (DEBUG_OUTPUT)
		printf("Message::Message -- creating datagram (%d)\n", dgram_size);

	// we create the dgram
	if (_raw != NULL){ free(_raw); }
	_raw = new char[dgram_size];

	// fill the dgram with type 
	_raw[0] = _type;	

	// fill the dgram with timestamp 
	dgram_stamp = _stamp->getRaw();
	memcpy((_raw + dgram_stamp_idx),
			dgram_stamp, _stamp->getRawSize());
	free(dgram_stamp);

	// fill the dgram with message
	short ds = htons(_data_size);
	memcpy((_raw + dgram_messagesize_idx),
			&ds, 
			2);
	memcpy((_raw + dgram_messagedata_idx),
			_data,
			_data_size);

	if (DEBUG_OUTPUT)
		printf("Message::raw -- MESSAGE(%c,\n\t",type);
	for (int i=0; i < _size; i++){
		if (DEBUG_OUTPUT)
			printf("%#x ", _raw[i]);
	}
	if (DEBUG_OUTPUT) printf(")\n");

}


char * Message::getRaw(){
	char * result = new char[_size];
	memcpy(result, _raw, _size);

	if (DEBUG){
		pDEBUG("hex: \n");
		for (int i=0; i < _size; i++){
			printf("%#x ", result[i]);
		}
		printf("\n");
	}

	return result;
}


size_t Message::getRawSize(){ 
	pDEBUG("%d\n",_size);
	return _size;
}


char * Message::getData(){
	char * result = new char[_data_size];
	memcpy(result, _data, _data_size);

	return result;
}

short Message::getDataSize(){
	return _data_size;
}



TimeStamp Message::getStamp(){
	return *_stamp;
}


Protocol::Type Message::getType(){
	return _type;
}


bool Message::operator==(Message &message) {
	printf("Message::operator== -- \n");
	return (message.getStamp() == this->getStamp());
}

#undef DEBUG_INPUT
#undef DEBUG_OUTPUT