opportunistic-xbee/packet.cpp

#include "packet.h"

Packet::Packet(){
	msg.data = malloc(1 * sizeof(char));
}
Packet::~Packet(){
	free(msg.data);
}
/* PUBLIC
----------------------------------------*/
// builds a packet from raw data and returns the error code
uint8_t Packet::read(uint8_t* buf, const size_t size){
	// 1. fail on invalid size
	if( size < 1          ) return PKTREAD_EMPTY;
	if( size > PROTO_SIZE ) return PKTREAD_OVERFLOW;

	// 2. extract packet type
	opcode = buf[0];

	// 3. extract depending on type
	return (opcode == 0) ? read_discover(buf, size) : read_message(buf, size);

};

// writes the binary representation of the packet
size_t Packet::write(uint8_t* buf){
	if( opcode == 0 )
		return write_discover(buf);

	return write_message(buf);
};

/* GETTERS / SETTERS
----------------------------------------*/
uint8_t Packet::getOpcode()           { return opcode; }
void Packet::setOpcode(uint8_t value) { opcode = value; dsc.opcode = value; msg.opcode = value; }

uint8_t Packet::getWave()           { return dsc.wave; }
void Packet::setWave(uint8_t value) { dsc.wave = value; }

uint8_t Packet::getSender()           { return msg.sender; }
void Packet::setSender(uint8_t value) { msg.sender = value; }

uint8_t Packet::getDist()           { return (opcode == 0) ? dsc.dist : msg.dist; }
void Packet::setDist(uint8_t value) { if(opcode == 0) dsc.dist = value; else msg.dist = value; }

uint8_t Packet::getTTL()           { return msg.ttl; }
void Packet::setTTL(uint8_t value) { msg.ttl = value; }

uint8_t Packet::getSize()           { return msg.size; }

uint8_t* Packet::getData(){ return msg.data; }
void Packet::setData(uint8_t *buffer) {
	if( strlen(buffer) >= 255 )
		return;

	msg.size = strlen(buffer);

	resizeMessage();
	strcpy(msg.data, buffer);
}



/* PRIVATE
----------------------------------------*/
uint8_t Packet::read_discover(uint8_t *buf, const size_t size){
	// 1. fail on invalid size
	if( size != DISCOVER_SIZE )
		return PKTREAD_INVALID_DISCOVER_FORMAT;

	dsc.opcode = buf[0];
	dsc.wave   = buf[1];
	dsc.dist   = buf[2];

	return PKTREAD_OK;
};


size_t Packet::write_discover(uint8_t *buf){
	buf[0] = dsc.opcode;
	buf[1] = dsc.wave;
	buf[2] = dsc.dist;

	return 3;
};


uint8_t Packet::read_message(uint8_t *buf, const size_t size){
	// 1. fail on invalid size
	if( size < MESSAGE_MIN_SIZE || size > MESSAGE_MAX_SIZE )
		return PKTREAD_INVALID_MESSAGE_FORMAT;

	// 2. fill values
	msg.opcode = buf[0];
	msg.sender = buf[1];
	msg.dist   = buf[2];
	msg.ttl    = buf[3];
	msg.size   = buf[4];

	// 3. check message size
	if( size - 5 != msg.size )
		return PKTREAD_INVALID_MESSAGE_FORMAT;

	// 4. extract message
	resizeMessage();
	strncpy(msg.data, buf+5, msg.size);

	return PKTREAD_OK;
};

size_t Packet::write_message(uint8_t *buf){
	buf[0] = msg.opcode;
	buf[1] = msg.sender;
	buf[2] = msg.dist;
	buf[3] = msg.ttl;
	buf[4] = msg.size;

	buf = realloc(buf, (5+msg.size+1)* sizeof(uint8_t));
	strncpy(buf+5, msg.data, msg.size);

	return 5 + msg.size;
};