message.h

/***************************************************************************
*   Copyright (C) 2005 by                                                 *
*   Pedro J. Fernandez Ruiz    pedroj.fernandez@dif.um.es                 *
*   Alejandro Perez Mendez     alejandro_perez@dif.um.es                  *
*                                                                         *
*   This library is free software; you can redistribute it and/or         *
*   modify it under the terms of the GNU Lesser General Public            *
*   License as published by the Free Software Foundation; either          *
*   version 2.1 of the License, or (at your option) any later version.    *
*                                                                         *
*   This library 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     *
*   Lesser General Public License for more details.                       *
*                                                                         *
*   You should have received a copy of the GNU Lesser General Public      *
*   License along with this library; if not, write to the Free Software   *
*   Foundation, Inc., 51 Franklin St, Fifth Floor,                        *
*   Boston, MA  02110-1301  USA                                           *
***************************************************************************/
#ifndef MESSAGE_H
#define MESSAGE_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "payload.h"
#include "payload_sk.h"
#include "cipher.h"
#include "payload_notify.h"
#include "ipaddress.h"
#include "autovector.h"

using namespace std;

namespace openikev2 {

    class Message : public Printable {

            /****************************** ENUMS ******************************/
        public:
            enum EXCHANGE_TYPE {
                IKE_SA_INIT = 34,   
                IKE_AUTH,           
                CREATE_CHILD_SA,    
                INFORMATIONAL       
        };

            enum MESSAGE_TYPE {
                REQUEST = 0,        
                RESPONSE            
        };

            /****************************** ATTRIBUTES ******************************/
        protected:
            AutoVector<Payload> unencrypted_payloads;   
            AutoVector<Payload> encrypted_payloads;     
            Payload::PAYLOAD_TYPE first_payload_type;   
            Payload::PAYLOAD_TYPE first_payload_type_sk; 
            auto_ptr<IpAddress> src_addr;               
            auto_ptr<IpAddress> dst_addr;               
            auto_ptr<ByteArray> binary_representation;  
            auto_ptr<Payload_SK> payload_sk;            
        public:
            bool can_use_higher_major_version;          
            uint8_t major_version;                      
            uint8_t minor_version;                      
            EXCHANGE_TYPE exchange_type;                
            MESSAGE_TYPE message_type;                  
            bool is_initiator;                          
            uint64_t spi_i;                             
            uint64_t spi_r;                             
            uint32_t message_id;                        
            /****************************** METHODS ******************************/
        protected:
            static Payload::PAYLOAD_TYPE generatePayloads( Payload::PAYLOAD_TYPE first_payload_type, ByteBuffer& byte_buffer, vector<Payload*> &payloads );

            static auto_ptr<ByteArray> generateBinaryRepresentation( Payload::PAYLOAD_TYPE last_payload_type, const vector<Payload*> payloads );

        public:
            Message( auto_ptr<IpAddress> src_addr, auto_ptr<IpAddress> dst_addr, uint64_t spi_i, uint64_t spi_r, uint8_t major_version, uint8_t minor_version, EXCHANGE_TYPE exchange_type, MESSAGE_TYPE message_type, bool is_initiator, bool can_use_higher_major_version, uint32_t message_id );

            Message( auto_ptr<IpAddress> src_addr, auto_ptr<IpAddress> dst_addr, ByteBuffer& byte_buffer );

            Message( const Message& other );

            vector<Payload*> getPayloadsByType( Payload::PAYLOAD_TYPE type ) const;

            Payload* getFirstPayloadByType( Payload::PAYLOAD_TYPE type ) const;

            Payload& getUniquePayloadByType( Payload::PAYLOAD_TYPE type ) const;

            vector<Payload_NOTIFY*> getNotifiesByType( Payload_NOTIFY::NOTIFY_TYPE notification_type ) const ;

            Payload_NOTIFY* getFirstNotifyByType( Payload_NOTIFY::NOTIFY_TYPE notification_type ) const;

            Payload_NOTIFY& getUniqueNotifyByType( Payload_NOTIFY::NOTIFY_TYPE notification_type ) const;

            void addPayload( auto_ptr<Payload> payload, bool is_encrypted );

            void replaceFirstPayloadByType( Payload::PAYLOAD_TYPE type, auto_ptr<Payload> new_payload );

            void replaceFirstNotifyByType( Payload_NOTIFY::NOTIFY_TYPE notify_type, auto_ptr< Payload_NOTIFY > new_payload );

            void addPayloadNotify( auto_ptr<Payload_NOTIFY> notify_payload, bool is_encrypted );

            void addPayloadsNotify( AutoVector<Payload_NOTIFY> notifies, bool is_encrypted );
            
            ByteArray& getBinaryRepresentation( Cipher *cipher );

            void decryptPayloadSK( Cipher *cipher );

            bool checkIntegrity( Cipher * cipher ) const;

            auto_ptr<Message> clone() const;

            IpAddress& getSrcAddress() const;

            IpAddress& getDstAddress() const;


            static string EXCHANGE_TYPE_STR( EXCHANGE_TYPE exchange_type );
            
            static string MESSAGE_TYPE_STR( MESSAGE_TYPE message_type );

            virtual string toStringTab( uint8_t tabs ) const ;

            virtual ~Message();

    };
};
#endif

---