D:/Storage/CVS_Head/h323plus/include/h460/h4601.h

// H4601.h:
/*
 * Virteos H.460 Implementation for the h323plus Library.
 *
 * Virteos is a Trade Mark of ISVO (Asia) Pte Ltd.
 *
 * Copyright (c) 2004 ISVO (Asia) Pte Ltd. All Rights Reserved.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the General Public License (the  "GNU License"), in which case the
 * provisions of GNU License are applicable instead of those
 * above. If you wish to allow use of your version of this file only
 * under the terms of the GNU License and not to allow others to use
 * your version of this file under the MPL, indicate your decision by
 * deleting the provisions above and replace them with the notice and
 * other provisions required by the GNU License. If you do not delete
 * the provisions above, a recipient may use your version of this file
 * under either the MPL or the GNU License."
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is derived from and used in conjunction with the 
 * OpenH323 Project (www.openh323.org/)
 *
 * The Initial Developer of the Original Code is ISVO (Asia) Pte Ltd.
 *
 *
 * Contributor(s): ______________________________________.
 *
* $Log: h4601.h,v $
* Revision 1.1  2007/08/06 20:50:51  shorne
* First commit of h323plus
*
*
*/

#if !defined(_H460_H)
#define _H460_H


#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include "h225.h"
#include "transports.h"
#include "guid.h"
#include <ptlib/pluginmgr.h>
#include <ptclib/url.h>


#ifdef _MSC_VER
#pragma warning(disable:4100)
#endif


template<class H225>
class H460 : public H225 {
public:
        
    virtual void OnReceivedPDU(
      const H225 & /*id*/
          ) {};

    virtual BOOL OnSendingPDU(
      H225 & /*id*/
          ) const { return FALSE;};
        
protected:

};

class OpalOID : public PASN_ObjectId
{
public:

        OpalOID();

        OpalOID(
      const char * str  
    );

        OpalOID & operator+(const char *);

        unsigned GetLastIdentifier() {
         return (*this)[GetSize()-1];
        }
};




class H460_FeatureID : public H460<H225_GenericIdentifier>
{

  public:

        H460_FeatureID();

        H460_FeatureID(unsigned ID);

    H460_FeatureID(OpalOID ID);

        H460_FeatureID(PString ID);

        H460_FeatureID(H225_GenericIdentifier ID);

       operator unsigned () const 
                { return ((PASN_Integer *)choice)->GetValue(); };

       operator OpalOID & () 
           { return (OpalOID &)*choice; };

       operator PString () const 
           { return ((H225_GloballyUniqueID *)choice)->AsString(); };

    
           PINLINE H460_FeatureID & operator=(unsigned ID);

           PINLINE H460_FeatureID & operator=(OpalOID ID);

           PINLINE H460_FeatureID & operator=(PString ID);
         
           unsigned GetFeatureType() const { return GetTag(); };

           PString IDString() const;

    PObject * Clone() const;

        PObject::Comparison Compare(const PObject & obj) const;

};



class H460_Feature;
class H460_FeatureTable;
class H460_FeatureContent : public H460<H225_Content>
{
 
   public:

           H460_FeatureContent();

           H460_FeatureContent(PASN_OctetString & param);

           H460_FeatureContent(const PString & param);

           H460_FeatureContent(PASN_BMPString & param);

           H460_FeatureContent(BOOL param);

           H460_FeatureContent(unsigned param, unsigned len);

           H460_FeatureContent(const H460_FeatureID & id);

           H460_FeatureContent(const H225_AliasAddress & add);

       H460_FeatureContent(const PURL & add);

           H460_FeatureContent(const H323TransportAddress & add);

           H460_FeatureContent(const H460_FeatureTable & table);

           H460_FeatureContent(const OpalGloballyUniqueID & guid);

           H460_FeatureContent(H460_Feature * data);

           H460_FeatureContent(const H225_Content & param);


        operator PASN_OctetString () const { return *((PASN_OctetString *)choice); };
        operator PString () const
        { 
                switch (GetTag()) {
                        case e_text:  
                                return ((PASN_IA5String &)*choice).GetValue();
                        case e_transport: 
                                return H323TransportAddress(*(H225_TransportAddress *)choice);
                }
                
                return PString();
        }; 

        operator PASN_BMPString () const { return *(PASN_BMPString *)choice; };
        operator BOOL () const { return *(PASN_Boolean *)choice; };

        operator unsigned () const 
        { 
                switch (GetTag()) {
                        case e_number8:  
                        case e_number16:
                        case e_number32: 
                                return *(PASN_Integer*)choice;
                        default: 
                                return 0;
                 }
        }
                
        operator H460_FeatureID () const { return *(H225_GenericIdentifier *)choice; };
        operator H225_AliasAddress () const { return *(H225_AliasAddress *)choice; };
        operator H323TransportAddress () const { return H323TransportAddress(*(H225_TransportAddress *)choice); };
        operator H460_FeatureTable *() { return (H460_FeatureTable *)choice; };
        operator H460_Feature *() { return (H460_Feature *)choice; };

};


class H460_Feature;
class H460_FeatureParameter : public H460<H225_EnumeratedParameter>
{
 
  public:

    H460_FeatureParameter();

    H460_FeatureParameter(unsigned Identifier);

        H460_FeatureParameter(const PString & Identifier);

        H460_FeatureParameter(const OpalOID & Identifier);

        H460_FeatureParameter(const H225_EnumeratedParameter & param);

        H460_FeatureParameter(const H460_FeatureID & ID);

        const H460_FeatureID ID() { return m_id; };

         void addContent(const H460_FeatureContent & con ) 
         { IncludeOptionalField(e_content);  m_content = con; };

         void replaceContent(const H460_FeatureContent & con )
                        { if (hasContent())  
                                        delete &m_content; 
                                m_content = con; };

         BOOL hasContent() 
                        { return (GetTag() == e_content); };



        operator PASN_OctetString &();
        operator PString &();
        operator PASN_BMPString &();
        operator BOOL ();
        operator unsigned ();
        operator H460_FeatureID &();
        operator H225_AliasAddress &();
        operator H323TransportAddress ();
        operator H225_ArrayOf_EnumeratedParameter &();
        operator PURL &();
        operator OpalGloballyUniqueID ();


        H460_FeatureContent operator=(
        const PASN_OctetString & value
        );

        H460_FeatureContent operator=(
        const PString & value
        );

        H460_FeatureContent operator=(
        const PASN_BMPString & value
        );

        H460_FeatureContent operator=(
        const BOOL & value
        );

        H460_FeatureContent operator=(
        const unsigned & value
        );

        H460_FeatureContent operator=(
        const H460_FeatureID & value
        );

        H460_FeatureContent operator=(
        const H225_AliasAddress & value
        );

        H460_FeatureContent operator=(
        const H323TransportAddress & value
        );

        H460_FeatureContent operator=(
        const H460_FeatureTable & value
        );

        H460_FeatureContent operator=(
        H460_Feature * value
        );

        H460_FeatureContent operator=(
        const OpalGloballyUniqueID & value
        );


};


class H460_FeatureTable : public H460<H225_ArrayOf_EnumeratedParameter>

{
  public:

        H460_FeatureTable();

        H460_FeatureTable(const H225_ArrayOf_EnumeratedParameter & Xparams);


        H460_FeatureParameter & AddParameter(H460_FeatureID & id, H460_FeatureContent & con);

        H460_FeatureParameter & AddParameter(H460_FeatureID & id);

        void AddParameter(H225_EnumeratedParameter & Xparam);

        H460_FeatureParameter & GetParameter(PINDEX id);

    H460_FeatureParameter & GetParameter(const H460_FeatureID & id);

        PINDEX GetParameterIndex(const H460_FeatureID & id);

        BOOL HasParameter(const H460_FeatureID & id);

        void RemoveParameter(PINDEX id);

        void RemoveParameter(const H460_FeatureID & id);

    void ReplaceParameter(const H460_FeatureID & id, H460_FeatureContent & con);

        int ParameterCount() { return GetSize(); };

        BOOL ParameterIsUnique(const H460_FeatureID & id);

    inline H460_FeatureParameter & operator[](
      PINDEX id  
    ) const { return operator[](id); };

        H460_FeatureParameter & operator[](
      PINDEX id  
    );

};


class H323EndPoint;
class H323Connection;
class H460_Feature : public H460<H225_FeatureDescriptor>
{
  public:

        H460_Feature();

    H460_Feature(unsigned Identifier);

        H460_Feature(PString Identifier);

        H460_Feature(OpalOID Indentifier);

        H460_Feature(const H225_FeatureDescriptor & descriptor);



        enum {
      FeatureNeeded = 1,      
      FeatureDesired,         
      FeatureSupported        
        } FeatureCategory;


        enum {
          FeatureBase      =4,        
          FeatureBaseAll   =5,        
          FeatureBaseRas   =6,        
          FeatureBaseSignal=7,        
      FeatureRas       =8,        
          FeatureSignal    =16        
        } FeatureInstance;


       operator unsigned () const { return (H460_FeatureID)m_id; };

 //      operator OpalOID () const { return (H460_FeatureID)m_id; };

       operator PString () const { return (H460_FeatureID)m_id; };

           H460_FeatureID GetFeatureID() { return m_id; };

       void SetFeatureID(const H460_FeatureID & id) { m_id = id; };

           PString GetFeatureIDAsString();

           unsigned GetFeatureType() { return ((H460_FeatureID)m_id).GetFeatureType(); };

        virtual H460_FeatureParameter & AddParameter(H460_FeatureID * id, H460_FeatureContent & con);

        virtual H460_FeatureParameter & AddParameter(H460_FeatureID * id);

        virtual void AddParameter(H460_FeatureParameter * param);

        virtual void RemoveParameter(PINDEX id);

        virtual void ReplaceParameter(H460_FeatureID id, H460_FeatureContent & con);

    H460_FeatureParameter & GetFeatureParameter(PINDEX id);

    H460_FeatureParameter & GetFeatureParameter(const H460_FeatureID & id);

        BOOL HasFeatureParameter(const H460_FeatureID & id);
 
        BOOL Contains(const H460_FeatureID & id);

    H460_FeatureParameter & Value(const H460_FeatureID & id);

    inline H460_FeatureParameter & operator()(
      PINDEX id  //* Index position in the collection of the object.
    ) const { return operator()(id); };

        H460_FeatureParameter & operator()(
      PINDEX id  
    );

    inline H460_FeatureParameter & operator[](
      const H460_FeatureID & id  //< FeatureID of the object.
    ) const { return operator()(id); };

        H460_FeatureParameter & operator()(
      const H460_FeatureID & id  
    );

        int GetParameterCount() 
                { return CurrentTable->ParameterCount(); };

        H460_FeatureTable & GetCurrentTable();

        void SetCurrentTable(H460_FeatureTable & table);

        void SetCurrentTable(H460_FeatureParameter & param);

        void SetDefaultTable();


        static PStringList GetFeatureNames(PPluginManager * pluginMgr = NULL);

        static PStringList GetFeatureFriendlyNames(const PString & feature, PPluginManager * pluginMgr = NULL);

    static H460_Feature * CreateFeature(const PString & featurename,        
                                                                                int FeatureType = FeatureBase,          
                                                                                PPluginManager * pluginMgr = NULL   
                                        );
    static PStringList GetFeatureName() { return PStringList("empty"); };

    static PStringList GetFeatureFriendlyName() { return PStringList("empty"); };

        static int GetPurpose() { return FeatureBase; };

        virtual void AttachEndPoint(H323EndPoint * _ep);

        virtual void AttachConnection(H323Connection * _con);


        /* These are the main calls which can be overridden to
                allow the various derived features access to the GEF
                interface.
        */
  // PDU calls (Used in the H225_RAS Class)
    virtual BOOL OnSendGatekeeperRequest(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendGatekeeperConfirm(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendGatekeeperReject(H225_FeatureDescriptor & pdu) { return FALSE; };

    virtual void OnReceiveGatekeeperRequest(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveGatekeeperConfirm(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveGatekeeperReject(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendRegistrationRequest(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendRegistrationConfirm(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendRegistrationReject(H225_FeatureDescriptor & pdu) { return FALSE; };

    virtual void OnReceiveRegistrationRequest(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveRegistrationConfirm(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveRegistrationReject(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendAdmissionRequest(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendAdmissionConfirm(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendAdmissionReject(H225_FeatureDescriptor & pdu) { return FALSE; };

    virtual void OnReceiveAdmissionRequest(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveAdmissionConfirm(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveAdmissionReject(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendLocationRequest(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendLocationConfirm(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendLocationReject(H225_FeatureDescriptor & pdu) { return FALSE; };

    virtual void OnReceiveLocationRequest(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveLocationConfirm(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveLocationReject(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendServiceControlIndication(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual BOOL OnSendServiceControlResponse(H225_FeatureDescriptor & pdu) { return FALSE; };

    virtual void OnReceiveServiceControlIndication(const H225_FeatureDescriptor & pdu) {};
    virtual void OnReceiveServiceControlResponse(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendNonStandardMessage(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveNonStandardMessage(const H225_FeatureDescriptor & pdu) {};

        virtual BOOL OnSendUnregistrationRequest(H225_FeatureDescriptor & pdu) { return FALSE; };
        virtual void OnReceiveUnregistrationRequest(const H225_FeatureDescriptor & pdu) {};

        virtual BOOL OnSendEndpoint(H225_FeatureDescriptor & pdu) { return FALSE; };
        virtual void OnReceiveEndpoint(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendInfoRequestMessage(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveInfoRequestMessage(const H225_FeatureDescriptor & pdu) {};

        virtual BOOL OnSendInfoRequestResponseMessage(H225_FeatureDescriptor & pdu) { return FALSE; };
        virtual void OnReceiveInfoRequestResponseMessage(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendDisengagementRequestMessage(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveDisengagementRequestMessage(const H225_FeatureDescriptor & pdu) {};

        virtual BOOL OnSendDisengagementConfirmMessage(H225_FeatureDescriptor & pdu) { return FALSE; };
        virtual void OnReceiveDisengagementConfirmMessage(const H225_FeatureDescriptor & pdu) {};

  // UUIE Calls (Used in the H323SignalPDU Class)
    virtual BOOL OnSendSetup_UUIE(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveSetup_UUIE(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendAlerting_UUIE(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveAlerting_UUIE(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendCallProceeding_UUIE(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveCallProceeding_UUIE(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendCallConnect_UUIE(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveCallConnect_UUIE(const H225_FeatureDescriptor & pdu) {};

    virtual BOOL OnSendFacility_UUIE(H225_FeatureDescriptor & pdu) { return FALSE; };
    virtual void OnReceiveFacility_UUIE(const H225_FeatureDescriptor & pdu) {};

        virtual BOOL OnSendReleaseComplete_UUIE(H225_FeatureDescriptor & pdu) { return FALSE; };
        virtual void OnReceiveReleaseComplete_UUIE(const H225_FeatureDescriptor & pdu) {};

        virtual BOOL OnSendUnAllocatedPDU(H225_FeatureDescriptor & pdu) { return FALSE; };
        virtual void OnReceivedUnAllocatedPDU(const H225_FeatureDescriptor & pdu) {};


  // H501 Calls (To Be Implemented
                // H501_MessageCommonInfo
                // H501_AddressTemplate
                // H501_ContactInformation
                // H501_RouteInformation

  protected:
          H460_FeatureTable * CurrentTable;
          H323EndPoint * ep;
          H323Connection * con;
};

class H460_FeatureStd : public H460_Feature
{
    PCLASSINFO(H460_FeatureStd, H460_Feature);
  public:

          H460_FeatureStd() {};

        H460_FeatureStd(unsigned Identifier);

        H460_FeatureParameter & Add(unsigned id, H460_FeatureContent & con);

        void Remove(unsigned id);

        void Replace(unsigned id, H460_FeatureContent & con);

        BOOL HasParameter(unsigned id);

        H460_FeatureParameter & GetParameter(unsigned id);

    inline H460_FeatureParameter & operator[] (
      unsigned id  
    ) { return GetParameter(id); };

};

class H460_FeatureNonStd : public H460_Feature
{
    PCLASSINFO(H460_FeatureNonStd, H460_Feature);
  public:

        H460_FeatureNonStd(PString Identifier);

        H460_FeatureParameter & Add(PString id, H460_FeatureContent & con);

        void Remove(PString id);

        void Replace(PString id, H460_FeatureContent & con);

        BOOL HasParameter(PString id);


    inline H460_FeatureParameter & operator[](
      PString id  
    ) const { return operator[](id); };

        H460_FeatureParameter & operator[](
      PString id  
    );

};

class H460_FeatureOID : public H460_Feature
{
    PCLASSINFO(H460_FeatureOID, H460_Feature);
  public:

        H460_FeatureOID(OpalOID Identifier);

        H460_FeatureParameter & Add(const PString & id, H460_FeatureContent & con);

        void Remove(const PString & id);

        void Replace(const PString & id, H460_FeatureContent & con);

        BOOL HasParameter(OpalOID id);

        BOOL Contains(const PString & id);

        H460_FeatureParameter & Value(const PString & id);


    inline H460_FeatureParameter & operator[](
      OpalOID id  
    ) const { return operator[](id); };

        H460_FeatureParameter & operator[](
      OpalOID id  
    );

  protected:
    PString GetBase();

};
// Dictionary/List of Features

PDICTIONARY(H460_Features, H460_FeatureID , H460_Feature);

// FeatureSet Main Calling Class
class H323EndPoint;
class H460_FeatureSet : public PObject
{
    PCLASSINFO(H460_FeatureSet, PObject);
  public:

        H460_FeatureSet();

    H460_FeatureSet(H460_FeatureSet * _base);

        H460_FeatureSet(const H225_FeatureSet & fs);

        H460_FeatureSet(const H225_ArrayOf_GenericData & generic);

        H460_FeatureSet & DeriveNewFeatureSet();

        virtual BOOL LoadFeatureSet(int inst = H460_Feature::FeatureBase,
                                                  H323Connection * con = NULL);

        BOOL ProcessFirstPDU(const H225_FeatureSet & fs);

        virtual BOOL CreateFeatureSet(const H225_FeatureSet & fs);

        virtual BOOL LoadFeature(const PString & featid);
        
        BOOL AddFeature(H460_Feature * Nfeat);

        void RemoveFeature(H460_FeatureID id);

        H460_Feature * GetFeature(const H460_FeatureID & id);

        BOOL HasFeature(const H460_FeatureID & feat);

        void ReceiveFeature(unsigned id, const H225_FeatureSet & Message);

        BOOL SendFeature(unsigned id, H225_FeatureSet & Message);       

        virtual void AttachEndPoint(H323EndPoint * _ep);

        virtual void AttachBaseFeatureSet(H460_FeatureSet * _baseSet);

        H323EndPoint * GetEndPoint() { return ep; };

  protected:

   BOOL CreateFeatureSetPDU(H225_FeatureSet & fs, unsigned MessageID);

   void ReadFeatureSetPDU(const H225_FeatureSet & fs, unsigned MessageID);

   H460_FeatureID GetFeatureIDPDU(H225_FeatureDescriptor & pdu);

   BOOL CreateFeaturePDU(H460_Feature & Feat, H225_FeatureDescriptor & pdu, unsigned MessageID);
   void ReadFeaturePDU(H460_Feature & Feat, const H225_FeatureDescriptor & pdu, unsigned MessageID);

   PString PTracePDU(PINDEX id) const;

   H460_Features  Features;
   H323EndPoint * ep;
   H460_FeatureSet * baseSet;

};


template <class className> class H460PluginServiceDescriptor : public PDevicePluginServiceDescriptor
{
  public:
    virtual PObject *   CreateInstance(int /*userData*/) const { return new className; }
    virtual PStringList GetDeviceNames(int /*userData*/) const { return className::GetFeatureFriendlyName(); }
    virtual bool  ValidateDeviceName(const PString & deviceName, int userData) const 
        { 
             PStringList devices = className::GetFeatureName(); 
                 if ((deviceName == devices[0]) &&
                         (className::GetPurpose() >= userData) && 
                         (className::GetPurpose() < userData*2)) {

                        return TRUE; 
                 } else
                            return FALSE;
        } 
};

#define H460_FEATURE(name)    \
static H460PluginServiceDescriptor<H460_Feature##name> H460_Feature##name##_descriptor; \
PCREATE_PLUGIN(H460_Feature##name##, H460_Feature, &H460_Feature##name##_descriptor); \


#ifdef _MSC_VER
#pragma warning(disable:4100)
#endif

#endif // !defined(_H460_H)

---