m2.mbcp/src/message.cc

#include <netinet/in.h>

#include "message.h"

#define DEBUG_INPUT		0
#define DEBUG_OUTPUT	0

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;

	/*
	short stamp_index = -1;
	short stamp_len = -1;
	switch(_type){
		case Protocol::TYPE_ABCAST : 
			{
				memcpy(&stamp_index, (_raw + index), 2);
				stamp_index = ntohs(stamp_index);
				stamp_len = 1; // 2 * 2 octets;
				index += 2;
			}
			break;
		case Protocol::TYPE_CBCAST :
			{
				// on est super embétés...
				// on regarde d'abord l'index...
				// stamp_len = 4i
				memcpy(&stamp_index, (_raw + index), 2);
				stamp_index = ntohs(stamp_index);
				index += 2;

				memcpy(&stamp_len, (_raw + index), 2);
				index += 2;
			}
			break;
		case Protocol::TYPE_TEST :
			{
				// taille = 0;
				stamp_len = 0;
			}
			break;
		case Protocol::TYPE_UNKNOWN : 
			break;
		default :
			break;
	}

	if (DEBUG_INPUT) {
		printf("Message::Message(void *, int) -- stamp_index %d\n", stamp_index);
		printf("Message::Message(void *, int) -- stamp_len %d\n", stamp_len);
	}
	if (stamp_len < 0){
		fprintf(stderr, "Longueur du timestamp inconnue\n !");
		exit(-1);
	}
	_stamp = new TimeStamp(_type, stamp_index);	
	// on itere stamp_len fois sur 2 octets
	for (int i = 0; i< stamp_len; i++){
		short site_value;
		memcpy(&site_value, (_raw + index), 2);
		site_value = ntohs(site_value);

		if (DEBUG_INPUT) 
			printf("Message::Message -- horloge[%d] = %d\n", i, site_value);

		index += 2;
		_stamp->push_back(site_value);
	}
	*/
	_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);
	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, 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);

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

	return result;
}


size_t Message::getRawSize(){ 
	printf("Message::getRawSize -- %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