Header.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "Header.h"
#include "Exception.h"
#include <netinet/in.h>

using namespace DTN;

//============================================
// SDNV --- Self-delimiting numerical values
//============================================

SDNV::SDNV( const ByteString& s )
{
   m_val.clear();
   const unsigned char mask = 0x80;
   ByteString::const_iterator itr = s.begin();
   ByteString::const_iterator end = s.end();
   for ( ; itr != end ; ++itr )
   {
      m_val += *itr;
      // if the first bit isn't set, this *must* be the last byte
      if ( !( mask & *itr ) ) break;
   }
}

SDNV&
SDNV::operator=( const SDNV& v )
{
   if ( this != &v )
   {
      m_val = v.val();
   }
   return *this;
}

SDNV::operator uint64_t() const
{
   uint64_t l = 0;
   const unsigned char mask = 0x7F;
   ByteString::const_iterator itr = m_val.begin();
   ByteString::const_iterator end = m_val.end();
   for ( unsigned char n = 0 ; itr != end ; ++itr, ++n )
   {
      unsigned char temp = mask & *itr;
      unsigned char avail_bits = 8*sizeof(l) - 7*n;
      if ( (temp>>1) >= (1U<<(avail_bits-1)) )
      {
         throw Exception( __FILE__ , __LINE__ );
      }
      l <<= 7;
      l += (mask & *itr);
   }
   return l;
}

void
SDNV::assign( uint64_t l )
{
   const unsigned char mask = 0x7F;
   if ( m_val.size() != 0 )
   {
      m_val.clear();
   }
   while ( 0 != l )
   {
      unsigned char temp = l & mask;
      if ( ! m_val.empty() )
      {
         temp |= 0x80;
      }
      m_val.insert(0,1,temp);
      l >>= 7;
   }
}


//========================================
// Header --- Base class for DTN headers
//========================================

Header::Header()
{
}

Header::Header( const ByteString& hdr ) :
   m_data( hdr )
{
}

Header::Header( const Header& hdr ) :
   m_data( hdr.m_data )
{
}

Header::~Header()
{
}


//=============================================================
// PrimaryHeader --- Basic forwarding information header type
//=============================================================

PrimaryHeader::PrimaryHeader() :
   m_parsed ( false ),
   m_destinationSchemeOffset ( 0 ),
   m_destinationSSPOffset( 0 ),
   m_sourceSchemeOffset( 0 ),
   m_sourceSSPOffset( 0 ),
   m_reportToSchemeOffset( 0 ),
   m_reportToSSPOffset( 0 ),
   m_custodianSchemeOffset( 0 ),
   m_custodianSSPOffset( 0 ),
   m_creationTime( 0 ),
   m_creationSeqNum( 0 ),
   m_lifetime( 0 )
{
}

PrimaryHeader::PrimaryHeader( const ByteString& hdr ) :
   Header( hdr ),
   m_parsed ( false ),
   m_destinationSchemeOffset ( 0 ),
   m_destinationSSPOffset( 0 ),
   m_sourceSchemeOffset( 0 ),
   m_sourceSSPOffset( 0 ),
   m_reportToSchemeOffset( 0 ),
   m_reportToSSPOffset( 0 ),
   m_custodianSchemeOffset( 0 ),
   m_custodianSSPOffset( 0 ),
   m_creationTime( 0 ),
   m_creationSeqNum( 0 ),
   m_lifetime( 0 )
{
}

PrimaryHeader::PrimaryHeader( const PrimaryHeader& hdr ) :
   Header( hdr ),
   m_parsed ( false ),
   m_destinationSchemeOffset ( 0 ),
   m_destinationSSPOffset( 0 ),
   m_sourceSchemeOffset( 0 ),
   m_sourceSSPOffset( 0 ),
   m_reportToSchemeOffset( 0 ),
   m_reportToSSPOffset( 0 ),
   m_custodianSchemeOffset( 0 ),
   m_custodianSSPOffset( 0 ),
   m_creationTime( 0 ),
   m_creationSeqNum( 0 ),
   m_lifetime( 0 )
{
}

PrimaryHeader::~PrimaryHeader()
{
}

uint16_t
PrimaryHeader::stringToShort( ByteString::size_type offset ) const
{
   if ( m_data.length() < (offset+2) ) throw Exception( __FILE__ , __LINE__ );
   union { unsigned char c[2]; uint16_t s; } temp;
   temp.c[0] = m_data[offset];
   temp.c[1] = m_data[offset+1];
   return ntohs(temp.s);
}

uint32_t
PrimaryHeader::stringToInt( ByteString::size_type offset ) const
{
   if ( m_data.length() < (offset+4) ) throw Exception( __FILE__ , __LINE__ );
   union { unsigned char c[4]; uint32_t l; } temp;
   temp.c[0] = m_data[offset];
   temp.c[1] = m_data[offset+1];
   temp.c[2] = m_data[offset+2];
   temp.c[3] = m_data[offset+3];
   return ntohl(temp.l);
}

unsigned char
PrimaryHeader::version() const
{
   if ( m_data.length() < 1 ) throw Exception( __FILE__ , __LINE__ );
   return m_data[0];
}

unsigned char
PrimaryHeader::flags() const
{
   if ( m_data.length() < 2 ) throw Exception( __FILE__ , __LINE__ );
   return m_data[1];
}

unsigned char
PrimaryHeader::COS() const
{
   if ( m_data.length() < 3 ) throw Exception( __FILE__ , __LINE__ );
   return m_data[2];
}

unsigned char
PrimaryHeader::SRR() const
{
   if ( m_data.length() < 4 ) throw Exception( __FILE__ , __LINE__ );
   return m_data[3];
}

void
PrimaryHeader::parse() const
{
   // We take advantage of a bit of magic here.  Namely, m_data[] will
   // throw if the index is invalid.  This allows us to be cavalier
   // about checking.

   ByteString::size_type offset = 4;
   ByteString temp;

   do
   {
      temp += m_data[offset++];
   } while ( temp[temp.length()-1] & 0x80 );
   m_length = temp;

   m_destinationSchemeOffset = stringToShort( offset ); offset += 2;
   m_destinationSSPOffset = stringToShort( offset ); offset += 2;
   m_sourceSchemeOffset = stringToShort( offset ); offset += 2;
   m_sourceSSPOffset = stringToShort( offset ); offset += 2;
   m_reportToSchemeOffset = stringToShort( offset ); offset += 2;
   m_reportToSSPOffset = stringToShort( offset ); offset += 2;
   m_custodianSchemeOffset = stringToShort( offset ); offset += 2;
   m_custodianSSPOffset = stringToShort( offset ); offset += 2;

   m_creationTime = stringToInt( offset ); offset += 4;
   m_creationSeqNum = stringToInt( offset ); offset += 4;
   m_lifetime = stringToInt( offset ); offset += 4;

   temp.clear();
   do
   {
      temp += m_data[offset++];
   } while ( temp[temp.length()-1] & 0x80 );
   m_dictionaryLength = temp;

   ByteString::size_type end = offset + m_dictionaryLength;
   for ( ; offset < end ; ++offset )
   {
      m_dictionary += m_data[offset];
   }

   temp.clear();
   do
   {
      temp += m_data[offset++];
   } while ( temp[temp.length()-1] & 0x80 );
   m_fragmentOffset = temp;

   temp.clear();
   do
   {
      temp += m_data[offset++];
   } while ( temp[temp.length()-1] & 0x80 );
   m_applicationDataUnitLength = temp;

   m_parsed = true;
}

const SDNV&
PrimaryHeader::length() const
{
   if ( ! m_parsed ) parse();
   return m_length;
}

uint16_t
PrimaryHeader::destinationSchemeOffset() const
{
   if ( ! m_parsed ) parse();
   return m_destinationSchemeOffset;
}

uint16_t
PrimaryHeader::destinationSSPOffset() const
{
   if ( ! m_parsed ) parse();
   return m_destinationSSPOffset;
}

uint16_t
PrimaryHeader::sourceSchemeOffset() const
{
   if ( ! m_parsed ) parse();
   return m_sourceSchemeOffset;
}

uint16_t
PrimaryHeader::sourceSSPOffset() const
{
   if ( ! m_parsed ) parse();
   return m_sourceSSPOffset;
}

uint16_t
PrimaryHeader::reportToSchemeOffset() const
{
   if ( ! m_parsed ) parse();
   return m_reportToSchemeOffset;
}

uint16_t
PrimaryHeader::reportToSSPOffset() const
{
   if ( ! m_parsed ) parse();
   return m_reportToSSPOffset;
}

uint16_t
PrimaryHeader::custodianSchemeOffset() const
{
   if ( ! m_parsed ) parse();
   return m_custodianSchemeOffset;
}

uint16_t
PrimaryHeader::custodianSSPOffset() const
{
   if ( ! m_parsed ) parse();
   return m_custodianSSPOffset;
}

uint32_t
PrimaryHeader::creationTime() const
{
   if ( ! m_parsed ) parse();
   return m_creationTime;
}

uint32_t
PrimaryHeader::creationSeqNum() const
{
   if ( ! m_parsed ) parse();
   return m_creationSeqNum;
}

uint32_t
PrimaryHeader::lifetime() const
{
   if ( ! m_parsed ) parse();
   return m_lifetime;
}

const SDNV&
PrimaryHeader::dictionaryLength() const
{
   if ( ! m_parsed ) parse();
   return m_dictionaryLength;
}

const ByteString&
PrimaryHeader::dictionary() const
{
   if ( ! m_parsed ) parse();
   return m_dictionary;
}

const SDNV&
PrimaryHeader::fragmentOffset() const
{
   if ( ! m_parsed ) parse();
   return m_fragmentOffset;
}

const SDNV&
PrimaryHeader::applicationDataUnitLength() const
{
   if ( ! m_parsed ) parse();
   return m_applicationDataUnitLength;
}


//==========================================================
// RegularHeader --- Base type for non-primary DTN headers
//==========================================================

RegularHeader::RegularHeader()
{
}

RegularHeader::RegularHeader( const ByteString& hdr ) :
   Header( hdr )
{
}

RegularHeader::RegularHeader( const RegularHeader& hdr ) :
   Header( hdr )
{
}

RegularHeader::~RegularHeader()
{
}

unsigned char
RegularHeader::typeCode() const
{
   if ( 0 == m_data.length() )
   {
      throw Exception( __FILE__ , __LINE__ );
   }
   return m_data[0];
}

unsigned char
RegularHeader::flags() const
{
   if ( m_data.length() < 2 )
   {
      throw Exception( __FILE__ , __LINE__ );
   }
   return m_data[1];
}

SDNV
RegularHeader::length() const
{
   ByteString s;
   for ( unsigned int i = 2; i < m_data.length() ; ++i )
   {
      s += m_data[i];
      if ( !(0x80 & m_data[i]) ) // the high bit is 0
      {
         return s;
      }
   }
   throw Exception( __FILE__ , __LINE__ );
}


//============================================
// PayloadHeader --- Data-holding DTN header
//============================================

PayloadHeader::PayloadHeader()
{
}

PayloadHeader::PayloadHeader( const ByteString& pld, unsigned char flags )
{
   m_data.clear();
   m_data += kPayloadHeader;
   m_data += flags;
   SDNV length = pld.length();
   m_data += length.val();
   m_data += pld;
}

PayloadHeader::PayloadHeader( const PayloadHeader& hdr ) :
   RegularHeader( hdr )
{
}

PayloadHeader::~PayloadHeader()
{
}

ByteString
PayloadHeader::payload() const
{
   return m_data.substr(m_offset);
}

---