h323con.h

Go to the documentation of this file.

/*
 * h323con.h
 *
 * H.323 protocol handler
 *
 * Open H323 Library
 *
 * Copyright (c) 1998-2001 Equivalence Pty. Ltd.
 *
 * 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/
 *
 * 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 Open H323 Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions of this code were written with the assisance of funding from
 * Vovida Networks, Inc. http://www.vovida.com.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 32213 $
 * $Author: rjongbloed $
 * $Date: 2014-06-25 10:57:02 +1000 (Wed, 25 Jun 2014) $
 */

#ifndef OPAL_H323_H323CON_H
#define OPAL_H323_H323CON_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#if OPAL_H323

#include <rtp/rtpconn.h>
#include <opal/guid.h>
#include <opal_config.h>
#include <h323/h323caps.h>
#include <h323/h235dh.h>
#include <h460/h460.h>
#include <ptclib/dtmf.h>


/* The following classes have forward references to avoid including the VERY
   large header files for H225 and H245. If an application requires access
   to the protocol classes they can include them, but for simple usage their
   inclusion can be avoided.
 */
class PPER_Stream;
class PASN_OctetString;
class PASN_Sequence;

class H225_EndpointType;
class H225_TransportAddress;
class H225_ArrayOf_PASN_OctetString;
class H225_ProtocolIdentifier;
class H225_AdmissionRequest;
class H225_AdmissionConfirm;
class H225_AdmissionReject;
class H225_InfoRequestResponse;
class H225_DisengageRequest;
class H225_FeatureSet;
class H225_H245Security;

class H245_TerminalCapabilitySet;
class H245_TerminalCapabilitySetReject;
class H245_OpenLogicalChannel;
class H245_OpenLogicalChannelAck;
class H245_TransportAddress;
class H245_UserInputIndication;
class H245_RequestMode;
class H245_RequestModeAck;
class H245_RequestModeReject;
class H245_ModeDescription;
class H245_ArrayOf_ModeDescription;
class H245_SendTerminalCapabilitySet;
class H245_MultiplexCapability;
class H245_FlowControlCommand;
class H245_MiscellaneousCommand;
class H245_MiscellaneousIndication;
class H245_JitterIndication;
class H245_ArrayOf_GenericParameter;
class H245_ArrayOf_GenericInformation;

class H323SignalPDU;
class H323ControlPDU;
class H323EndPoint;
class H323TransportAddress;
class H323_RTPChannel;
typedef OpalMediaSession H323RTPSession;

class H235Authenticators;

class H245NegMasterSlaveDetermination;
class H245NegTerminalCapabilitySet;
class H245NegLogicalChannels;
class H245NegRequestMode;
class H245NegRoundTripDelay;

class H450xDispatcher;
class H4502Handler;
class H4504Handler;
class H4506Handler;
class H4507Handler;
class H45011Handler;

class OpalCall;

class H460_FeatureSet;


#define OPAL_OPT_Q931_BEARER_CAPS "Q931-Bearer-Caps"



class H323Connection : public OpalRTPConnection
{
  PCLASSINFO(H323Connection, OpalRTPConnection);

  public:
    H323Connection(
      OpalCall & call,                         
      H323EndPoint & endpoint,                 
      const PString & token,                   
      const PString & alias,                   
      const H323TransportAddress & address,    
      unsigned options = 0,                    
      OpalConnection::StringOptions * stringOptions = NULL 
    );

    ~H323Connection();

    virtual bool IsNetworkConnection() const { return true; }

    virtual PString GetPrefixName() const;

    virtual void OnApplyStringOptions();

    virtual PBoolean SetUpConnection();

    virtual PBoolean SetAlerting(
      const PString & calleeName,   
      PBoolean withMedia                
    );

    virtual PBoolean SetConnected();

    virtual PBoolean SetProgressed();
    
    virtual void OnEstablished();

    virtual void OnReleased();

    virtual OpalTransportAddress GetRemoteAddress() const { return GetTransport().GetRemoteAddress(); }

    virtual PString GetDestinationAddress();

    virtual PString GetAlertingType() const;

    virtual bool SetAlertingType(const PString & info);

    unsigned GetProgressIndicator() const { return m_progressIndicator; }

    void SetProgressIndicator(unsigned indicator) { m_progressIndicator = indicator; }

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual PStringArray GetMediaCryptoSuites() const;

    virtual unsigned GetNextSessionID(
      const OpalMediaType & mediaType,   
      bool isSource                      
    );

#if OPAL_T38_CAPABILITY

    virtual bool SwitchFaxMediaStreams(
      bool toT38  
    );
#endif

    virtual OpalMediaStreamPtr OpenMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource                        
    );
    
    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

    virtual bool GetMediaTransportAddresses(
      OpalConnection & otherConnection,      
      const OpalMediaType & mediaType,       
      OpalTransportAddressArray & transports 
    ) const;

#if OPAL_H239

    virtual bool RequestPresentationRole(
      bool release   
    );

    virtual bool HasPresentationRole() const;
#endif // OPAL_H239


    void AttachSignalChannel(
      const PString & token,    
      H323Transport * channel,  
      PBoolean answeringCall        
    );

    PBoolean WriteSignalPDU(
      H323SignalPDU & pdu       
    );

    virtual void HandleSignallingChannel();

    virtual PBoolean HandleSignalPDU(
      H323SignalPDU & pdu       
    );

    virtual void HandleTunnelPDU(
      H323SignalPDU * txPDU       
    );

    virtual PBoolean OnReceivedSignalSetup(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedSignalSetupAck(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedSignalInformation(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedCallProceeding(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedProgress(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedAlerting(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedSignalConnect(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedFacility(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedSignalNotify(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedSignalStatus(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnReceivedStatusEnquiry(
      const H323SignalPDU & pdu   
    );

    virtual void OnReceivedReleaseComplete(
      const H323SignalPDU & pdu   
    );

    virtual PBoolean OnUnknownSignalPDU(
      const H323SignalPDU & pdu  
    );

    virtual void OnSendARQ(
      H225_AdmissionRequest & arq
    );

    virtual void OnReceivedACF(
      const H225_AdmissionConfirm & acf
    );

    virtual void OnReceivedARJ(
      const H225_AdmissionReject & arj
    );

    virtual void OnSendIRR(
      H225_InfoRequestResponse & irr
    ) const;

    virtual void OnSendDRQ(
      H225_DisengageRequest & drq
    ) const;

    virtual PBoolean OnIncomingCall(
      const H323SignalPDU & setupPDU,   
      H323SignalPDU & alertingPDU       
    );

    virtual PBoolean ForwardCall(
      const PString & forwardParty   
    );

    virtual bool TransferConnection(
      const PString & remoteParty   
    );

    virtual bool HoldRemote(
      bool placeOnHold  
    );

    virtual bool IsOnHold(
      bool fromRemote  
    ) const;

#if OPAL_H450

    bool TransferCall(
      const PString & remoteParty,   
      const PString & callIdentity = PString::Empty()
    );

    void ConsultationTransfer(
      const PString & primaryCallToken  
    );

    virtual void HandleConsultationTransfer(
      const PString & callIdentity, 
      H323Connection & incoming     
    );

    PBoolean IsTransferringCall() const;

    PBoolean IsTransferredCall() const;

    virtual void HandleTransferCall(
      const PString & token,
      const PString & identity
    );

    int GetCallTransferInvokeId();

    virtual void HandleCallTransferFailure(
      const int returnError    
    );

    void SetAssociatedCallToken(
      const PString & token  
    );

    virtual void OnConsultationTransferSuccess(
      H323Connection & secondaryCall  
    );

    virtual void IntrudeCall(
      unsigned capabilityLevel
    );

    virtual void HandleIntrudeCall(
      const PString & token,
      const PString & identity
    );

    void SetCallIntrusion() { isCallIntrusion = true; }

    PBoolean IsCallIntrusion() { return isCallIntrusion; }

    unsigned GetLocalCallIntrusionProtectionLevel() { return callIntrusionProtectionLevel; }

    virtual PBoolean GetRemoteCallIntrusionProtectionLevel(
      const PString & callToken,
      unsigned callIntrusionProtectionLevel
    );

    virtual void SetIntrusionImpending();

    virtual void SetForcedReleaseAccepted();

    virtual void SetIntrusionNotAuthorized();

    void SendCallWaitingIndication(
      const unsigned nbOfAddWaitingCalls = 0   
    );

#endif

    virtual AnswerCallResponse OnAnswerCall(
      const PString & callerName,       
      const H323SignalPDU & setupPDU,   
      H323SignalPDU & connectPDU,       
      H323SignalPDU & progressPDU       
    );
    
    virtual AnswerCallResponse OnAnswerCall(
      const PString & callerName        
    );

    void AnsweringCall(
      AnswerCallResponse response 
    );

    virtual CallEndReason SendSignalSetup(
      const PString & alias,                
      const H323TransportAddress & address  
    );

    virtual PBoolean OnSendSignalSetup(
      H323SignalPDU & setupPDU   
    );

    virtual PBoolean OnSendCallProceeding(
      H323SignalPDU & callProceedingPDU   
    );

    virtual PBoolean OnSendReleaseComplete(
      H323SignalPDU & releaseCompletePDU 
    );

    virtual PBoolean OnAlerting(
      const H323SignalPDU & alertingPDU,  
      const PString & user                
    );

    virtual PBoolean OnInsufficientDigits();

    virtual void SendMoreDigits(
      const PString & digits    
    );

    virtual PBoolean OnOutgoingCall(
      const H323SignalPDU & connectPDU   
    );

    virtual PBoolean SendFastStartAcknowledge(
      H225_ArrayOf_PASN_OctetString & array   
    );

    virtual PBoolean HandleFastStartAcknowledge(
      const H225_ArrayOf_PASN_OctetString & array   
    );

    virtual PBoolean CreateOutgoingControlChannel(
      const PASN_Sequence & enclosingPDU,         
      const H225_TransportAddress & h245Address,  
      unsigned h245AddressField,                  
      const H225_H245Security & h245Security,     
      unsigned h245SecurityField            
    );

    virtual PBoolean CreateIncomingControlChannel(
      PASN_Sequence & enclosingPDU,         
      H225_TransportAddress & h245Address,  
      unsigned h245AddressField,            
      H225_H245Security & h245Security,     
      unsigned h245SecurityField            
    );

    virtual PBoolean WriteControlPDU(
      const H323ControlPDU & pdu
    );

    virtual PBoolean StartControlNegotiations();

    virtual void HandleControlChannel();

    virtual PBoolean HandleControlData(
      PPER_Stream & strm
    );

    virtual PBoolean HandleControlPDU(
      const H323ControlPDU & pdu
    );

    virtual PBoolean HandleReceivedControlPDU(
      PBoolean readStatus,
      PPER_Stream & strm
    );

    virtual PBoolean OnUnknownControlPDU(
      const H323ControlPDU & pdu  
    );

    virtual PBoolean OnH245Request(
      const H323ControlPDU & pdu  
    );

    virtual PBoolean OnH245Response(
      const H323ControlPDU & pdu  
    );

    virtual PBoolean OnH245Command(
      const H323ControlPDU & pdu  
    );

    virtual PBoolean OnH245Indication(
      const H323ControlPDU & pdu  
    );

    virtual PBoolean OnH245_SendTerminalCapabilitySet(
      const H245_SendTerminalCapabilitySet & pdu  
    );

    virtual PBoolean OnH245_FlowControlCommand(
      const H245_FlowControlCommand & pdu  
    );

    virtual PBoolean OnH245_MiscellaneousCommand(
      const H245_MiscellaneousCommand & pdu  
    );

    virtual PBoolean OnH245_MiscellaneousIndication(
      const H245_MiscellaneousIndication & pdu  
    );

    virtual PBoolean OnH245_JitterIndication(
      const H245_JitterIndication & pdu  
    );

#if OPAL_H239

    virtual bool OnH239Message(
      unsigned subMessage,
      const H245_ArrayOf_GenericParameter & params
    );

    virtual bool OnH239FlowControlRequest(
      unsigned logicalChannel,
      unsigned bitRate
    );

    virtual bool OnH239FlowControlResponse(
      unsigned logicalChannel,
      bool rejected
    );

    virtual bool OnH239PresentationRequest(
      unsigned logicalChannel,
      unsigned symmetryBreaking,
      unsigned terminalLabel
    );

    virtual bool SendH239PresentationRequest(
      unsigned logicalChannel,
      unsigned symmetryBreaking,
      unsigned terminalLabel
    );

    virtual bool OnH239PresentationResponse(
      unsigned logicalChannel,
      unsigned terminalLabel,
      bool rejected
    );

    virtual bool OnH239PresentationRelease(
      unsigned logicalChannel,
      unsigned terminalLabel
    );

    virtual bool SendH239PresentationRelease(
      unsigned logicalChannel,
      unsigned terminalLabel
    );

    virtual bool OnH239PresentationIndication(
      unsigned logicalChannel,
      unsigned terminalLabel
    );
#endif // OPAL_H239

    enum ControlProtocolErrors {
      e_MasterSlaveDetermination,
      e_CapabilityExchange,
      e_LogicalChannel,
      e_ModeRequest,
      e_RoundTripDelay
    };

    virtual PBoolean OnControlProtocolError(
      ControlProtocolErrors errorSource,  
      const void * errorData = NULL       
    );

    virtual void OnSendCapabilitySet(
      H245_TerminalCapabilitySet & pdu  
    );

    virtual PBoolean OnReceivedCapabilitySet(
      const H323Capabilities & remoteCaps,      
      const H245_MultiplexCapability * muxCap,  
      H245_TerminalCapabilitySetReject & reject 
    );

    virtual bool SendCapabilitySet(
      PBoolean empty  
    );

    virtual bool IsSendingCapabilitySet();

    virtual void OnSetLocalCapabilities();

    virtual void OnSendH245_OpenLogicalChannel(
      H245_OpenLogicalChannel & /*open*/, 
      PBoolean /*forward*/
    ) { }

    PBoolean IsH245Master() const;

    void StartRoundTripDelay();

    PTimeInterval GetRoundTripDelay() const;

    virtual void OnSelectLogicalChannels();

    virtual void SelectDefaultLogicalChannel(
      const OpalMediaType & mediaType,  
      unsigned sessionID                
    );

    virtual void SelectFastStartChannels(
      unsigned sessionID,   
      PBoolean transmitter,     
      PBoolean receiver         
    );

    virtual void OpenFastStartChannel(
      unsigned sessionID,               
      H323Channel::Directions direction 
    );

    virtual PBoolean OpenLogicalChannel(
      const H323Capability & capability,  
      unsigned sessionID,                 
      H323Channel::Directions dir         
    );
    
    virtual void SendFlowControlCommand(
      unsigned channelNumber,
      unsigned newBitRate
    );
    
    virtual PBoolean OnOpenLogicalChannel(
      const H245_OpenLogicalChannel & openPDU,  
      H245_OpenLogicalChannelAck & ackPDU,      
      unsigned & errorCode,                     
      H323Channel & channel                     
    );

    virtual PBoolean OnConflictingLogicalChannel(
      H323Channel & channel    
    );

    virtual H323Channel * CreateLogicalChannel(
      const H245_OpenLogicalChannel & open, 
      PBoolean startingFast,                    
      unsigned & errorCode                  
    );

    virtual H323Channel * CreateRealTimeLogicalChannel(
      const H323Capability & capability, 
      H323Channel::Directions dir,       
      unsigned sessionID,                
      const H245_H2250LogicalChannelParameters * param
    );
    
    virtual H323_RTPChannel * CreateRTPChannel(
      const H323Capability & capability,
      H323Channel::Directions direction,
      H323RTPSession & rtp
    );

    virtual PBoolean OnCreateLogicalChannel(
      const H323Capability & capability,  
      H323Channel::Directions dir,        
      unsigned & errorCode                
    );

    virtual PBoolean OnStartLogicalChannel(
      H323Channel & channel    
    );

    virtual void CloseLogicalChannel(
      unsigned number,    
      PBoolean fromRemote     
    );

    virtual void CloseLogicalChannelNumber(
      const H323ChannelNumber & number    
    );

    virtual void CloseAllLogicalChannels(
      PBoolean fromRemote     
    );

    virtual void OnClosedLogicalChannel(
      const H323Channel & channel   
    );

    virtual PBoolean OnClosingLogicalChannel(
      H323Channel & channel   
    );

    virtual void OnLogicalChannelFlowControl(
      H323Channel * channel,   
      long bitRateRestriction  
    );

    virtual void OnLogicalChannelJitter(
      H323Channel * channel,   
      DWORD jitter,            
      int skippedFrameCount,   
      int additionalBuffer     
    );

    H323Channel * GetLogicalChannel(
      unsigned number,    
      PBoolean fromRemote     
    ) const;

    H323Channel * FindChannel(
      unsigned sessionId,   
      PBoolean fromRemote       
    ) const;

    virtual OpalBandwidth GetBandwidthUsed(
      OpalBandwidth::Direction dir   
    ) const;

    virtual SendUserInputModes GetRealSendUserInputMode() const;

    virtual PBoolean SendUserInputString(
      const PString & value                   
    );

    virtual PBoolean SendUserInputTone(
      char tone,             
      unsigned duration = 0  
    );

    virtual PBoolean SendUserInputIndicationQ931(
      const PString & value                   
    );

    virtual PBoolean SendUserInputIndicationString(
      const PString & value                   
    );

    virtual PBoolean SendUserInputIndicationTone(
      char tone,                   
      unsigned duration = 0,       
      unsigned logicalChannel = 0, 
      unsigned rtpTimestamp = 0    
    );

    virtual PBoolean SendUserInputIndication(
      const H245_UserInputIndication & pdu    
    );

    virtual void OnUserInputIndication(
      const H245_UserInputIndication & pdu  
    );

    virtual PString GetSessionCodecNames(
      unsigned sessionID
    ) const;

    virtual void DetermineRTPNAT(
      const OpalTransport & transport,          
      const OpalTransportAddress & signalAddr   
    );

    virtual PBoolean RequestModeChange(
      const PString & newModes  
    );

    virtual PBoolean RequestModeChange(
      const H245_ArrayOf_ModeDescription & newModes  
    );

    virtual PBoolean OnRequestModeChange(
      const H245_RequestMode & pdu,     
      H245_RequestModeAck & ack,        
      H245_RequestModeReject & reject,  
      PINDEX & selectedMode           
    );

    virtual void OnModeChanged(
      const H245_ModeDescription & newMode
    );

    virtual void OnAcceptModeChange(
      const H245_RequestModeAck & pdu  
    );

    virtual void OnRefusedModeChange(
      const H245_RequestModeReject * pdu  
    );

    virtual PBoolean RequestModeChangeT38(
      const char * capabilityNames = "T.38\nT38FaxUDP"
    );

    virtual PBoolean GetAdmissionRequestAuthentication(
      const H225_AdmissionRequest & arq,  
      H235Authenticators & authenticators 
    );

    H323EndPoint & GetEndPoint() const { return endpoint; }

    PBoolean HadAnsweredCall() const { return !IsOriginating(); }

    PBoolean IsGatekeeperRouted() const { return gatekeeperRouted; }

    unsigned GetDistinctiveRing() const { return distinctiveRing; }

    void SetDistinctiveRing(unsigned pattern) { distinctiveRing = pattern&7; }

    const PString & GetCallToken() const { return GetToken(); }

    unsigned GetCallReference() const { return callReference; }

    inline const OpalGloballyUniqueID & GetCallIdentifier() const 
    { return callIdentifier; }

    virtual PString GetIdentifier() const;

    const OpalGloballyUniqueID & GetConferenceIdentifier() const { return conferenceIdentifier; }

    void SetLocalPartyName(const PString & name);

    const PStringList & GetLocalAliasNames() const { return localAliasNames; }

    virtual void SetRemotePartyInfo(
      const H323SignalPDU & pdu 
    );

    void SetRemoteApplication(
      const H225_EndpointType & pdu 
    );
    
    enum ConferenceGoal {
        e_Create,
        e_Invite,
        e_Join
    };

    ConferenceGoal GetConferenceGoal() { return m_conferenceGoal; }

    void SetConferenceGoal(ConferenceGoal goal) { m_conferenceGoal = goal; }

    const H323Capabilities & GetLocalCapabilities() const { return localCapabilities; }

    const H323Capabilities & GetRemoteCapabilities() const { return remoteCapabilities; }

    unsigned GetRemoteMaxAudioDelayJitter() const { return remoteMaxAudioDelayJitter; }

    OpalTransportPtr GetSignallingChannel() const { return m_signallingChannel; }

    unsigned GetSignallingVersion() const { return h225version; }

    const H323Transport & GetControlChannel() const;

    OpalTransport & GetTransport() const;

    unsigned GetControlVersion() const { return h245version; }

    unsigned GetUUIEsRequested() const { return uuiesRequested; }

    void SetUUIEsRequested(unsigned mask) { uuiesRequested = mask; }

    const PString GetGkAccessTokenOID() const { return gkAccessTokenOID; }

    void SetGkAccessTokenOID(const PString & oid) { gkAccessTokenOID = oid; }

    const PBYTEArray & GetGkAccessTokenData() const { return gkAccessTokenData; }

    void SetDestExtraCallInfo(
      const PString & info
    ) { destExtraCallInfo = info; }

    void SetRemotCallWaiting(const unsigned value) { remoteCallWaiting = value; }

    int GetRemoteCallWaiting() const { return remoteCallWaiting; }

    void SetEnforcedDurationLimit(
      unsigned seconds  
    );


#if OPAL_H239

    bool GetLocalH239Control() const { return m_h239Control; }

    void SetLocalH239Control(
      bool on   
    ) { m_h239Control = on; }

    bool GetRemoteH239Control() const;

    OpalMediaFormatList GetRemoteH239Formats() const;
#endif

#if OPAL_H235_6

    const H235DiffieHellman & GetDiffieHellman() const { return m_dh; }
          H235DiffieHellman & GetDiffieHellman()       { return m_dh; }
#endif

#if OPAL_H450

    H4507Handler&  getH4507handler(){return *h4507handler;}
#endif

#if OPAL_H460

    H460_FeatureSet * GetFeatureSet() const { return m_features; }

    virtual bool OnSendFeatureSet(H460_MessageType pduType, H225_FeatureSet &) const;
    virtual void OnReceiveFeatureSet(H460_MessageType pduType, const H225_FeatureSet &) const;
#endif

    virtual void OnReceiveOLCGenericInformation(
      unsigned sessionID,
      const H245_ArrayOf_GenericInformation & info,
      bool isAck
    ) const;

   virtual bool OnSendingOLCGenericInformation(
     unsigned sessionID,                      
     H245_ArrayOf_GenericInformation & info,  
     bool isAck
   ) const;
    
    virtual bool OnMediaCommand(
      OpalMediaStream & stream,         
      const OpalMediaCommand & command  
    );

    P_DECLARE_ENUM(CompatibilityIssues,
      e_NoMultipleTunnelledH245, 
      e_BadMasterSlaveConflict,  
      e_NoUserInputCapability,   
      e_H224MustBeSession3,      
      e_NeedTCSAfterNonEmptyTCS, 
      e_NeedMSDAfterNonEmptyTCS, 
      e_ForceMaintainConnection  
    );
    P_DECLARE_ENUM_NAMES(CompatibilityIssues,
      "No-Multiple-Tunnelled-H245",
      "Bad-Master-Slave-Conflict",
      "No-User-Input-Capability",
      "H.224-Must-Be-Session-3",
      "Need-TCS-after-Non-Empty-TCS",
      "Need-MSD-after-Non-Empty-TCS",
      "Force-Maintain-TCP-Connection"
    );

    bool HasCompatibilityIssue(
      CompatibilityIssues issue
    ) const;

    PBoolean StartHandleControlChannel();
    virtual PBoolean OnStartHandleControlChannel();
    void EndHandleControlChannel();
 
  protected:
    virtual void InternalEstablishedConnectionCheck();
    bool InternalEndSessionCheck(PPER_Stream & strm);
    bool SendReleaseComplete();
    void SetRemoteVersions(const H225_ProtocolIdentifier & id);
    void SetOutgoingBearerCapabilities(H323SignalPDU & pdu) const;
    void SetIncomingBearerCapabilities(const H323SignalPDU & pdu);
    void MonitorCallStatus();
    PDECLARE_NOTIFIER(PThread, H323Connection, NewOutgoingControlChannel);
    PDECLARE_AcceptHandlerNotifier(H323Connection, NewIncomingControlChannel);

    H323EndPoint & endpoint;

    H323TransportAddress m_remoteConnectAddress;
    int                  remoteCallWaiting; // Number of call's waiting at the remote endpoint
    bool                 gatekeeperRouted;
    unsigned             distinctiveRing;
    unsigned             callReference;
    unsigned             m_progressIndicator;
    OpalGloballyUniqueID callIdentifier;
    OpalGloballyUniqueID conferenceIdentifier;

    PString            localDestinationAddress;
    PStringList        localAliasNames;
    H323Capabilities   localCapabilities; // Capabilities local system supports
    PString            destExtraCallInfo;
    H323Capabilities   remoteCapabilities; // Capabilities remote system supports
    unsigned           remoteMaxAudioDelayJitter;
    PTimer             roundTripDelayTimer;
    unsigned           uuiesRequested;
    PString            gkAccessTokenOID;
    PBYTEArray         gkAccessTokenData;
    bool               addAccessTokenToSetup;

    OpalTransportPtr m_signallingChannel;
    OpalTransportPtr m_controlChannel;
    OpalListener  * controlListener;
    bool            h245Tunneling;
    H323SignalPDU * h245TunnelRxPDU;
    H323SignalPDU * h245TunnelTxPDU;
    H323SignalPDU * setupPDU;
    H323SignalPDU * alertingPDU;
    H323SignalPDU * connectPDU;
    H323SignalPDU * progressPDU;

    P_DECLARE_TRACED_ENUM(ConnectionStates,
      NoConnectionActive,
      AwaitingGatekeeperAdmission,
      AwaitingTransportConnect,
      AwaitingSignalConnect,
      AwaitingLocalAnswer,
      HasExecutedSignalConnect,
      EstablishedConnection,
      ShuttingDownConnection
    );
    ConnectionStates connectionState;

    unsigned   h225version;
    unsigned   h245version;
    bool       h245versionSet;
    bool       doH245inSETUP;
    bool       lastPDUWasH245inSETUP;
    bool       m_forceSymmetricTCS;

    bool       mustSendDRQ;
    bool       mediaWaitForConnect;
    bool       m_holdToRemote;
    bool       earlyStart;
    PString    t38ModeChangeCapabilities;
    PSyncPoint digitsWaitFlag;
    bool       m_releaseCompleteNeeded;
    bool       m_endSessionNeeded;
    PSyncPoint endSessionReceived;
    PTimer     enforcedDurationLimit;
    bool       isConsultationTransfer;
    bool       m_maintainConnection;

    template <class PDU> void SetMaintainConnectionFlag(const PDU & pdu)
    {
      if (pdu.HasOptionalField(PDU::e_maintainConnection) && pdu.m_maintainConnection)
        m_maintainConnection = true;
    }

    PSafeDictionary<POrdinalKey, OpalMediaStream> m_conflictingChannels;

    P_DECLARE_TRACED_ENUM(RemoteHoldStates,
      eOffHoldFromRemote,
      eOnHoldFromRemote,
      eRetrieveFromRemote
    );
    RemoteHoldStates m_holdFromRemote;

    ConferenceGoal m_conferenceGoal;

#if OPAL_H450

    bool     isCallIntrusion;
    unsigned callIntrusionProtectionLevel;
#endif

    P_DECLARE_TRACED_ENUM(FastStartStates,
      FastStartDisabled,
      FastStartInitiate,
      FastStartResponse,
      FastStartAcknowledged
    );
    FastStartStates        m_fastStartState;
    H323LogicalChannelList m_fastStartChannels;
    

    // The following pointers are to protocol procedures, they are pointers to
    // hide their complexity from the H323Connection classes users.
    H245NegMasterSlaveDetermination  * masterSlaveDeterminationProcedure;
    H245NegTerminalCapabilitySet     * capabilityExchangeProcedure;
    H245NegLogicalChannels           * logicalChannels;
    H245NegRequestMode               * requestModeProcedure;
    H245NegRoundTripDelay            * roundTripDelayProcedure;

#if OPAL_H239
    bool     m_h239Control;
    unsigned m_h239SymmetryBreaking;
    unsigned m_h239TokenChannel;
    unsigned m_h239TerminalLabel;
    bool     m_h239TokenOwned;
#endif

#if OPAL_H450
    H450xDispatcher * h450dispatcher;
    H4502Handler    * h4502handler;
    H4504Handler    * h4504handler;
    H4506Handler    * h4506handler;
    H4507Handler    * h4507handler;
    H45011Handler   * h45011handler;
#endif

#if OPAL_H460
    H460_FeatureSet * m_features;
#endif

#if OPAL_VIDEO
    PSimpleTimer m_h245FastUpdatePictureTimer;
#endif

#if OPAL_H235_6
    H235DiffieHellman m_dh;

    template <class PDU> void SetDiffieHellman(const PDU & pdu)
    {
      if (pdu.HasOptionalField(PDU::e_tokens))
        m_dh.FromTokens(pdu.m_tokens);
    }
#endif

    char         m_lastUserInputIndication;
    PSimpleTimer m_lastUserInputIndicationStart;
    PTimer       m_UserInputIndicationTimer;
    PDECLARE_NOTIFIER(PTimer, H323Connection, UserInputIndicationTimeout);

  private:
    P_REMOVE_VIRTUAL_VOID(CleanUpOnCallEnd());
    P_REMOVE_VIRTUAL_VOID(OnCleared());
    P_REMOVE_VIRTUAL_VOID(OnRTPStatistics(const OpalRTPSession &) const);
    P_REMOVE_VIRTUAL(PBoolean, OnOpenLogicalChannel(const H245_OpenLogicalChannel&,H245_OpenLogicalChannelAck&,unsigned&), false);
    P_REMOVE_VIRTUAL(PBoolean, OnOpenLogicalChannel(const H245_OpenLogicalChannel &, H245_OpenLogicalChannelAck &, unsigned &, const unsigned &), false);
    P_REMOVE_VIRTUAL_VOID(NatDetection(const PIPSocket::Address &, const PIPSocket::Address &));
    P_REMOVE_VIRTUAL(PBoolean, OnNatDetected(), false);
};


PDICTIONARY(H323CallIdentityDict, PString, H323Connection);


#endif // OPAL_H323

#endif // OPAL_H323_H323CON_H