Header.h

// 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.

#ifndef __DTN_HEADER_H__
#define __DTN_HEADER_H__

#include "config.h"
#include "ByteString.h"

namespace DTN
{

class SDNV
{
   public :
      SDNV() {}
      SDNV( uint64_t l ) { assign(l); }
      SDNV( const ByteString& s );
      SDNV( const SDNV& v ) : m_val( v.val() ) {}
      ~SDNV() {}

      SDNV& operator=( uint64_t l ) { assign(l); return *this; }
      SDNV& operator=( const SDNV& v );

      operator uint64_t() const;

      const ByteString& val() const { return m_val; }

   private :
      void assign( uint64_t l );

      ByteString  m_val;
};


class Header
{
   public :
      Header();
      Header( const ByteString& hdr );
      Header( const Header& hdr );
      virtual ~Header();

      const ByteString& data() const { return m_data; }

   protected :
      ByteString  m_data; 
};


class PrimaryHeader : public Header
{
   public :
      enum PrimaryBundleFlags
      {
         kBundleFlagFragment = ( 1U << 0 ),
         kBundleFlagAdmin    = ( 1U << 1 ),
         kBundleFlagNF       = ( 1U << 2 ),
         kBundleFlagCTR      = ( 1U << 3 ),
         kBundleFlagDEPS     = ( 1U << 4 ),
         kBundleFlagRsrv3    = ( 1U << 5 ),
         kBundleFlagRsrv2    = ( 1U << 6 ),
         kBundleFlagRsrv1    = ( 1U << 7 )
      };

      enum SRRFlags
      {
         kSRR_none = 0x00,
         kSRR_reception = 0x01,
         kSRR_custody = 0x02,
         kSRR_forward = 0x04,
         kSRR_deliver = 0x08,
         kSRR_delete = 0x10,
         kSRR_ack = 0x20,
         kSRR_rsrv2 = 0x40,
         kSRR_rsrv1 = 0x80
      };

      PrimaryHeader();
      PrimaryHeader( const ByteString& hdr );
      PrimaryHeader( const PrimaryHeader& hdr );
      virtual ~PrimaryHeader();

      unsigned char version() const;
      unsigned char flags() const;
      unsigned char COS() const;
      unsigned char SRR() const;
      const SDNV& length() const;
      uint16_t destinationSchemeOffset() const;
      uint16_t destinationSSPOffset() const;
      uint16_t sourceSchemeOffset() const;
      uint16_t sourceSSPOffset() const;
      uint16_t reportToSchemeOffset() const;
      uint16_t reportToSSPOffset() const;
      uint16_t custodianSchemeOffset() const;
      uint16_t custodianSSPOffset() const;
      uint32_t creationTime() const;
      uint32_t creationSeqNum() const;
      uint32_t lifetime() const;
      const SDNV& dictionaryLength() const;
      const ByteString& dictionary() const;
      const SDNV& fragmentOffset() const;
      const SDNV& applicationDataUnitLength() const;

   private :
      uint16_t stringToShort( ByteString::size_type offset ) const;
      uint32_t  stringToInt( ByteString::size_type offset ) const;
      void parse() const;

      mutable bool  m_parsed;

      mutable SDNV       m_length;
      mutable uint16_t   m_destinationSchemeOffset;
      mutable uint16_t   m_destinationSSPOffset;
      mutable uint16_t   m_sourceSchemeOffset;
      mutable uint16_t   m_sourceSSPOffset;
      mutable uint16_t   m_reportToSchemeOffset;
      mutable uint16_t   m_reportToSSPOffset;
      mutable uint16_t   m_custodianSchemeOffset;
      mutable uint16_t   m_custodianSSPOffset;
      mutable uint32_t   m_creationTime;
      mutable uint32_t   m_creationSeqNum;
      mutable uint32_t   m_lifetime;
      mutable SDNV       m_dictionaryLength;
      mutable ByteString m_dictionary;
      mutable SDNV       m_fragmentOffset;
      mutable SDNV       m_applicationDataUnitLength;
};


class RegularHeader : public Header
{
   public :
      enum Types
      {
         kUnknownHeader = 0U, 
         kPayloadHeader = 1U  
      };

      enum BundleHeaderFlags
      {
         kHeaderFlagRepl    = ( 1U << 0 ),
         kHeaderFlagStatus  = ( 1U << 1 ),
         kHeaderFlagDiscard = ( 1U << 2 ),
         kHeaderFlagLast    = ( 1U << 3 ),
         kHeaderFlagRsrv4   = ( 1U << 4 ),
         kHeaderFlagRsrv3   = ( 1U << 5 ),
         kHeaderFlagRsrv2   = ( 1U << 6 ),
         kHeaderFlagRsrv1   = ( 1U << 7 )
      };

      RegularHeader();
      RegularHeader( const ByteString& hdr );
      RegularHeader( const RegularHeader& hdr );
      virtual ~RegularHeader();

      unsigned char typeCode() const;
      unsigned char flags() const;
      SDNV length() const;
};


class PayloadHeader : public RegularHeader
{
   public :
      PayloadHeader();
      PayloadHeader( const ByteString& pld, unsigned char flags=0 );
      PayloadHeader( const PayloadHeader& hdr );
      virtual ~PayloadHeader();

      ByteString::size_type offset() const { return m_offset; }
      ByteString payload() const;

   private :
      ByteString::size_type  m_offset;
};

}; // DTN

#endif /* __DTN_HEADER_H__ */

---