//Editor-Info: -*- C++ -*-
//
//Subject: GSMP
//
//File: gsmpportmanagementmessages.h
//
//Version: $Revision: 1.4 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/06/18 05:21:57 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Harri Sunila
//
//Description:
//      Classes for GSMP Port Management Message messengers
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//      
//Licence:
//     
//
//History:
//

#ifndef __GSMP_GSMPPORTMANAGEMENTMESSAGES_H__
#define __GSMP_GSMPPORTMANAGEMENTMESSAGES_H__

#include "gsmpmessage.h"
#include "gsmpstate.h"
#include "gsmpdefs.h"

//
// Class: gsmpPortManagementMessage
//
// Description:
//

class gsmpPortManagementMessage: public gsmpMessage
{
    public:
        // Definition for message type

        static const pfByte PORT_MANAGEMENT = 32; 

        // Definitions for event flags.
        // Use bitwise or ( | ) to enable more than one

        static const pfByte GSMP_PORT_UP = 0x80;
        static const pfByte GSMP_PORT_DOWN = 0x40;
        static const pfByte GSMP_INVALID_VPIVCI = 0x20;
        static const pfByte GSMP_NEW_PORT = 0x10;
        static const pfByte GSMP_DEAD_PORT = 0x08;

        // Definitions for function field

        static const pfUlong BRING_UP = 1;
        static const pfUlong TAKE_DOWN = 2;
        static const pfUlong INTERNAL_LOOPBACK = 3;
        static const pfUlong EXTERNAL_LOOPBACK = 4;
        static const pfUlong BOTHWAY_LOOPBACK = 5;
        static const pfUlong RESET_INPUT_PORT = 6;
        static const pfUlong RESET_EVENT_FLAGS = 7;
        
        gsmpPortManagementMessage(const gsmpPortManagementMessage &other_);
        virtual ~gsmpPortManagementMessage(void);

        virtual pfFrame encodeFrame(void);
        virtual void decodeFrame(pfFrame &frame_);

        pfUlong getPort(void) const;
        pfUlong getPortSessionNumber(void) const;
        pfUlong getEventSequenceNumber(void) const;
        pfByte getEventFlags(void) const;
        pfByte getDuration(void) const;
        pfUlong getFunction(void) const;
        
    protected:
        gsmpPortManagementMessage(void);

        pfUlong _port;
        pfUlong _portSessionNumber;
        pfUlong _eventSequenceNumber;
        pfByte _eventFlags;
        pfByte _duration;
        pfUlong _function;
};


//
// Class: gsmpBringUpMessage
//
// Description:
//

class gsmpBringUpMessage : public gsmpPortManagementMessage
{
    public:
        gsmpBringUpMessage(void);
        gsmpBringUpMessage(pfByte result_,
                           pfUlong transactionIdentifier_,
                           pfUlong port_,
                           pfUlong portSessionNumber_);
        gsmpBringUpMessage(const gsmpBringUpMessage &other_);
        virtual ~gsmpBringUpMessage(void);

        virtual gsmpBringUpMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};


//
// Class: gsmpTakeDownMessage
//
// Description:
//

class gsmpTakeDownMessage : public gsmpPortManagementMessage
{
    public:
        gsmpTakeDownMessage(void);
        gsmpTakeDownMessage(pfByte result_,
                            pfUlong transactionIdentifier_,
                            pfUlong port_,
                            pfUlong portSessionNumber_);
        gsmpTakeDownMessage(const gsmpTakeDownMessage &other_);
        virtual ~gsmpTakeDownMessage(void);

        virtual gsmpTakeDownMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};


//
// Class: gsmpInternalLoopbackMessage
//
// Description:
//

class gsmpInternalLoopbackMessage : public gsmpPortManagementMessage
{
    public:
        gsmpInternalLoopbackMessage(void);
        gsmpInternalLoopbackMessage(pfByte result_,
                                    pfUlong transactionIdentifier_,
                                    pfUlong port_,
                                    pfUlong portSessionNumber_,
                                    pfByte duration_ );
        gsmpInternalLoopbackMessage(const gsmpInternalLoopbackMessage &other_);
        virtual ~gsmpInternalLoopbackMessage(void);

        virtual gsmpInternalLoopbackMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

//
// Class: gsmpExternalLoopbackMessage
//
// Description:
//

class gsmpExternalLoopbackMessage : public gsmpPortManagementMessage
{
    public:
        gsmpExternalLoopbackMessage(void);
        gsmpExternalLoopbackMessage(pfByte result_,
                                    pfUlong transactionIdentifier_,
                                    pfUlong port_,
                                    pfUlong portSessionNumber_,
                                    pfByte duration_ );
        gsmpExternalLoopbackMessage(const gsmpExternalLoopbackMessage &other_);
        virtual ~gsmpExternalLoopbackMessage(void);

        virtual gsmpExternalLoopbackMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};


//
// Class: gsmpBothwayLoopbackMessage
//
// Description:
//

class gsmpBothwayLoopbackMessage : public gsmpPortManagementMessage
{
    public:
        gsmpBothwayLoopbackMessage(void);
        gsmpBothwayLoopbackMessage(pfByte result_,
                                   pfUlong transactionIdentifier_,
                                   pfUlong port_,
                                   pfUlong portSessionNumber_,
                                   pfByte duration_ );
        gsmpBothwayLoopbackMessage(const gsmpBothwayLoopbackMessage &other_);
        virtual ~gsmpBothwayLoopbackMessage(void);

        virtual gsmpBothwayLoopbackMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};


//
// Class: gsmpResetInputPortMessage
//
// Description:
//

class gsmpResetInputPortMessage : public gsmpPortManagementMessage
{
    public:
        gsmpResetInputPortMessage(void);
        gsmpResetInputPortMessage(pfByte result_,
                                  pfUlong transactionIdentifier_,
                                  pfUlong port_,
                                  pfUlong portSessionNumber_);
        gsmpResetInputPortMessage(const gsmpResetInputPortMessage &other_);
        virtual ~gsmpResetInputPortMessage(void);

        virtual gsmpResetInputPortMessage* clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};


//
// Class: gsmpResetEventFlagsMessage
//
// Description:
//

class gsmpResetEventFlagsMessage : public gsmpPortManagementMessage
{
    public:
        gsmpResetEventFlagsMessage(void);
        gsmpResetEventFlagsMessage(pfByte result_,
                                   pfUlong transactionIdentifier_,
                                   pfUlong port_,
                                   pfUlong portSessionNumber_,
                                   pfByte eventFlags_ );
        gsmpResetEventFlagsMessage(const gsmpResetEventFlagsMessage &other_);
        virtual ~gsmpResetEventFlagsMessage(void);

        virtual gsmpResetEventFlagsMessage *clone(void);
        void apply(pfState *state_, pfProtocol *protocol_);
};

#endif // __GSMP_GSMPPORTMANAGEMENTMESSAGES_H__