MessageHeader.cpp

Go to the documentation of this file.

 
#include <algorithm>
#include <time.h>
#include <sstream>
 
#include "madara/exceptions/MemoryException.h"
#include "MessageHeader.h"
#include "madara/utility/Utility.h"
 
madara::transport::MessageHeader::MessageHeader()
  : size(encoded_size()),
    type(2),
    updates(0),
    quality(0),
    clock(0),
    timestamp(utility::get_time()),
    ttl(0)
{
  memcpy(madara_id, MADARA_IDENTIFIER, 7);
  madara_id[7] = 0;
 
  originator[0] = 0;
  domain[0] = 0;
}
 
madara::transport::MessageHeader::~MessageHeader() {}
 
uint32_t madara::transport::MessageHeader::encoded_size(void) const
{
  return sizeof(uint64_t) * 3  // size, clock, timestamp
         + sizeof(char) *(MADARA_IDENTIFIER_LENGTH + MADARA_DOMAIN_MAX_LENGTH +
                              MAX_ORIGINATOR_LENGTH + 1) +
         sizeof(uint32_t) * 3;  // type, updates, quality
}
 
uint32_t madara::transport::MessageHeader::static_encoded_size(void)
{
  return sizeof(uint64_t) * 3  // size, clock, timestamp
         + sizeof(char) *(MADARA_IDENTIFIER_LENGTH + MADARA_DOMAIN_MAX_LENGTH +
                              MAX_ORIGINATOR_LENGTH + 1) +
         sizeof(uint32_t) * 3;  // type, updates, quality
}
 
const char* madara::transport::MessageHeader::read(
    const char* buffer, int64_t& buffer_remaining)
{
  // Remove size field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(size))
  {
    memcpy(&size, buffer, sizeof(size));
    size = madara::utility::endian_swap(size);
    buffer += sizeof(size);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << sizeof(size) << " byte size field cannot fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(size);
 
  // Remove madara_id field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(char) * MADARA_IDENTIFIER_LENGTH)
  {
    utility::strncpy_safe(madara_id, buffer, MADARA_IDENTIFIER_LENGTH);
    buffer += sizeof(char) * MADARA_IDENTIFIER_LENGTH;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << MADARA_IDENTIFIER_LENGTH << " byte id encoding cannot fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
 
  buffer_remaining -= sizeof(char) * MADARA_IDENTIFIER_LENGTH;
 
  // Remove domain field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(char) * MADARA_DOMAIN_MAX_LENGTH)
  {
    utility::strncpy_safe(domain, buffer, MADARA_DOMAIN_MAX_LENGTH);
    buffer += sizeof(char) * MADARA_DOMAIN_MAX_LENGTH;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << MADARA_DOMAIN_MAX_LENGTH << " byte domain encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
 
  buffer_remaining -= sizeof(char) * MADARA_DOMAIN_MAX_LENGTH;
 
  // Remove originator from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(char) * MAX_ORIGINATOR_LENGTH)
  {
    utility::strncpy_safe(originator, buffer, MAX_ORIGINATOR_LENGTH);
    buffer += sizeof(char) * MAX_ORIGINATOR_LENGTH;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << MAX_ORIGINATOR_LENGTH << " byte originator encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(char) * MAX_ORIGINATOR_LENGTH;
 
  // Remove type field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(type))
  {
    memcpy(&type, buffer, sizeof(type));
    type = madara::utility::endian_swap(type);
    buffer += sizeof(type);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << sizeof(type) << " byte type encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(type);
 
  // Remove updates field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(updates))
  {
    memcpy(&updates, buffer, sizeof(updates));
    updates = madara::utility::endian_swap(updates);
    buffer += sizeof(updates);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << sizeof(updates) << " byte updates encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(updates);
 
  // Remove quality field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(quality))
  {
    memcpy(&quality, buffer, sizeof(quality));
    quality = madara::utility::endian_swap(quality);
    buffer += sizeof(quality);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << sizeof(quality) << " byte quality encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(quality);
 
  // Remove clock field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(clock))
  {
    memcpy(&clock, buffer, sizeof(clock));
    clock = madara::utility::endian_swap(clock);
    buffer += sizeof(clock);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << sizeof(clock) << " byte clock encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(clock);
 
  // Remove timestamp field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(timestamp))
  {
    memcpy(&timestamp, buffer, sizeof(timestamp));
    timestamp = madara::utility::endian_swap(timestamp);
    buffer += sizeof(timestamp);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::read: ";
    buffer << sizeof(timestamp) << " byte timestamp encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(timestamp);
 
  // Remove the time to live field from the buffer
  if(buffer_remaining >= 1)
  {
    memcpy(&ttl, buffer, 1);
    buffer += 1;
  }
  buffer_remaining -= 1;
 
  return buffer;
}
 
char* madara::transport::MessageHeader::write(
    char* buffer, int64_t& buffer_remaining)
{
  // Write size field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(size))
  {
    *(uint64_t*)buffer = madara::utility::endian_swap(size);
    buffer += sizeof(size);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << sizeof(size) << " byte size encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(size);
 
  // Write madara_id field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(char) * MADARA_IDENTIFIER_LENGTH)
  {
    utility::strncpy_safe(buffer, madara_id, MADARA_IDENTIFIER_LENGTH);
    buffer += sizeof(char) * MADARA_IDENTIFIER_LENGTH;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << MADARA_IDENTIFIER_LENGTH << " byte id encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(char) * MADARA_IDENTIFIER_LENGTH;
 
  // Write domain field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(char) * MADARA_DOMAIN_MAX_LENGTH)
  {
    utility::strncpy_safe(buffer, domain, MADARA_DOMAIN_MAX_LENGTH);
    buffer += sizeof(char) * MADARA_DOMAIN_MAX_LENGTH;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << MADARA_DOMAIN_MAX_LENGTH << " byte domain encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(char) * MADARA_DOMAIN_MAX_LENGTH;
 
  // Write originator from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(char) * MAX_ORIGINATOR_LENGTH)
  {
    utility::strncpy_safe(buffer, originator, MAX_ORIGINATOR_LENGTH);
    buffer += sizeof(char) * MAX_ORIGINATOR_LENGTH;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << MAX_ORIGINATOR_LENGTH << " byte originator encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(char) * MAX_ORIGINATOR_LENGTH;
 
  // Write type field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(type))
  {
    *(uint32_t*)buffer = madara::utility::endian_swap(type);
    buffer += sizeof(type);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << sizeof(type) << " byte type encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(type);
 
  // Write updates field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(updates))
  {
    *(uint32_t*)buffer = madara::utility::endian_swap(updates);
    buffer += sizeof(updates);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << sizeof(updates) << " byte updates encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(updates);
 
  // Write quality field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(quality))
  {
    *(uint32_t*)buffer = madara::utility::endian_swap(quality);
    buffer += sizeof(quality);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << sizeof(quality) << " byte quality encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(quality);
 
  // Write clock field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(clock))
  {
    *(uint64_t*)buffer = madara::utility::endian_swap(clock);
    buffer += sizeof(clock);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << sizeof(clock) << " byte clock encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(clock);
 
  // Write timestamp field from the buffer and update accordingly
  if((size_t)buffer_remaining >= sizeof(timestamp))
  {
    *(uint64_t*)buffer = madara::utility::endian_swap(timestamp);
    buffer += sizeof(timestamp);
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << sizeof(timestamp) << " byte timestamp encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= sizeof(timestamp);
 
  if(buffer_remaining >= 1)
  {
    memcpy(buffer, &ttl, 1);
    buffer += 1;
  }
  else
  {
    std::stringstream buffer;
    buffer << "MessageHeader::write: ";
    buffer << "1 byte ttl encoding cannot";
    buffer << " fit in ";
    buffer << buffer_remaining << " byte buffer\n";
 
    throw exceptions::MemoryException(buffer.str());
  }
  buffer_remaining -= 1;
 
  return buffer;
}
 
std::string madara::transport::MessageHeader::to_string(void)
{
  std::stringstream buffer;
 
  buffer << "141: size(8:" << size << "), ";
  buffer << "encoding(8:" << madara_id << "), ";
  buffer << "domain(32:" << domain << "), ";
  buffer << "orig(64:" << originator << "), ";
  buffer << "type(4:" << type << "), ";
  buffer << "numupdates(4:" << updates << "), ";
  buffer << "quality(4:" << quality << "), ";
  buffer << "clock(8:" << clock << "), ";
  buffer << "wallclock(8:" << timestamp << "), ";
  buffer << "ttl(1:" <<(int)ttl << "), ";
 
  return buffer.str();
}
 
uint64_t madara::transport::MessageHeader::get_size(const char* buffer)
{
  return(madara::utility::endian_swap(*(uint64_t*)buffer));
}
 
bool madara::transport::MessageHeader::equals(const MessageHeader& other)
{
  return size == other.size && type == other.type && updates == other.updates &&
         quality == other.quality && clock == other.clock &&
         timestamp == other.timestamp &&
         strncmp(madara_id, other.madara_id, MADARA_IDENTIFIER_LENGTH) == 0 &&
         strncmp(domain, other.domain, MADARA_DOMAIN_MAX_LENGTH) == 0 &&
         strncmp(originator, other.originator, MAX_ORIGINATOR_LENGTH) == 0;
}