h4601.h

Go to the documentation of this file.

// 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): Many thanks to Simon Horne.
 *
 * $Revision: 28069 $
 * $Author: rjongbloed $
 * $Date: 2012-07-20 10:45:49 +1000 (Fri, 20 Jul 2012) $
*/

#ifndef OPAL_H460_H4601_H
#define OPAL_H460_H4601_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#if OPAL_H460

#include <asn/h225.h>
#include <h323/transaddr.h>
#include <opal/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 PBoolean 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(PBoolean 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);
                        default:
                                break;
                }
                
                return PString();
        }; 

        operator PASN_BMPString () const { return *(PASN_BMPString *)choice; };
        operator PBoolean () 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; };

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



        operator PASN_OctetString &();
        operator PString &();
        operator PASN_BMPString &();
        operator PBoolean ();
        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 PBoolean & 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(const H460_FeatureID & id, const H460_FeatureContent & con);

        H460_FeatureParameter & AddParameter(const 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);

        PBoolean HasParameter(const H460_FeatureID & id);

        void RemoveParameter(PINDEX id);

        void RemoveParameter(const H460_FeatureID & id);

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

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

        PBoolean 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, const H460_FeatureContent & con);

        virtual H460_FeatureParameter & AddParameter(H460_FeatureID * id);

        virtual void AddParameter(H460_FeatureParameter * param);

        virtual void RemoveParameter(PINDEX id);

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

    H460_FeatureParameter & GetFeatureParameter(PINDEX id);

    H460_FeatureParameter & GetFeatureParameter(const H460_FeatureID & id);

        PBoolean HasFeatureParameter(const H460_FeatureID & id);
 
        PBoolean 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 PBoolean OnSendGatekeeperRequest(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean OnSendGatekeeperConfirm(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean 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 PBoolean OnSendRegistrationRequest(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean OnSendRegistrationConfirm(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean 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 PBoolean OnSendAdmissionRequest(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean OnSendAdmissionConfirm(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean 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 PBoolean OnSendLocationRequest(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean OnSendLocationConfirm(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean 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 PBoolean OnSendServiceControlIndication(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual PBoolean OnSendServiceControlResponse(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };

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

    virtual PBoolean OnSendNonStandardMessage(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveNonStandardMessage(const H225_FeatureDescriptor & /*pdu*/) {};

        virtual PBoolean OnSendUnregistrationRequest(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
        virtual void OnReceiveUnregistrationRequest(const H225_FeatureDescriptor & /*pdu*/) {};

        virtual PBoolean OnSendEndpoint(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
        virtual void OnReceiveEndpoint(const H225_FeatureDescriptor & /*pdu*/) {};

    virtual PBoolean OnSendInfoRequestMessage(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveInfoRequestMessage(const H225_FeatureDescriptor & /*pdu*/) {};

        virtual PBoolean OnSendInfoRequestResponseMessage(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
        virtual void OnReceiveInfoRequestResponseMessage(const H225_FeatureDescriptor & /*pdu*/) {};

    virtual PBoolean OnSendDisengagementRequestMessage(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveDisengagementRequestMessage(const H225_FeatureDescriptor & /*pdu*/) {};

        virtual PBoolean OnSendDisengagementConfirmMessage(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
        virtual void OnReceiveDisengagementConfirmMessage(const H225_FeatureDescriptor & /*pdu*/) {};

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

    virtual PBoolean OnSendAlerting_UUIE(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveAlerting_UUIE(const H225_FeatureDescriptor & /*pdu*/) {};

    virtual PBoolean OnSendCallProceeding_UUIE(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveCallProceeding_UUIE(const H225_FeatureDescriptor & /*pdu*/) {};

    virtual PBoolean OnSendCallConnect_UUIE(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveCallConnect_UUIE(const H225_FeatureDescriptor & /*pdu*/) {};

    virtual PBoolean OnSendFacility_UUIE(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
    virtual void OnReceiveFacility_UUIE(const H225_FeatureDescriptor & /*pdu*/) {};

        virtual PBoolean OnSendReleaseComplete_UUIE(H225_FeatureDescriptor & /*pdu*/) { return FALSE; };
        virtual void OnReceiveReleaseComplete_UUIE(const H225_FeatureDescriptor & /*pdu*/) {};

        virtual PBoolean 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, const H460_FeatureContent & con);

        void Remove(unsigned id);

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

        PBoolean 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(const PString id, const H460_FeatureContent & con);

        void Remove(const PString & id);

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

        PBoolean 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, const H460_FeatureContent & con);

        void Remove(const PString & id);

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

        PBoolean HasParameter(OpalOID id);

        PBoolean 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 & genericData);

    H460_FeatureSet * DeriveNewFeatureSet();

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

    PBoolean ProcessFirstPDU(const H225_FeatureSet & fs);

    virtual PBoolean CreateFeatureSet(const H225_FeatureSet & fs);

    virtual PBoolean LoadFeature(const PString & featid);

    PBoolean AddFeature(H460_Feature * feat);

    void RemoveFeature(H460_FeatureID id);

    H460_Feature * GetFeature(const H460_FeatureID & id);

    PBoolean HasFeature(const H460_FeatureID & feat);

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

    PBoolean SendFeature(unsigned id, H225_FeatureSet & Message);       

    virtual void AttachEndPoint(H323EndPoint * ep);

    virtual void AttachBaseFeatureSet(H460_FeatureSet * baseSet);

    H323EndPoint * GetEndPoint() { return m_endpoint; };

  protected:

    PBoolean CreateFeatureSetPDU(H225_FeatureSet & fs, unsigned MessageID);

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

    H460_FeatureID GetFeatureIDPDU(H225_FeatureDescriptor & pdu);

    PBoolean 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     m_features;
    H323EndPoint    * m_endpoint;
    H460_FeatureSet * m_baseSet;
};


template <class className> class H460PluginServiceDescriptor : public PDevicePluginServiceDescriptor
{
  public:
    virtual PObject *   CreateInstance(int /*userData*/) const { return new className; }
    virtual PStringArray 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_STATIC(name, H460_Feature, &H460_Feature##name##_descriptor); \


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

#endif // OPAL_H460

#endif // OPAL_H460_H4601_H