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: 30586 $
 * $Author: rjongbloed $
 * $Date: 2013-09-30 16:52:34 +1000 (Mon, 30 Sep 2013) $
 */

#ifndef OPAL_H323_H323CON_H
#define OPAL_H323_H323CON_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#if OPAL_H323

#include <rtp/rtpconn.h>
#include <opal/guid.h>
#include <opal/buildopts.h>
#include <h323/h323caps.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;

#if OPAL_H460
class H460_FeatureSet;
#endif


#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 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(
      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 Hold(
      bool fromRemote,  
      bool placeOnHold  
    );

    virtual bool IsOnHold(
      bool fromRemote  
    );

#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 PIPSocket::Address & localAddr,   
      const PIPSocket::Address & peerAddr,    
      const PIPSocket::Address & 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; }

    const H323Transport * 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

    virtual PBoolean OnSendFeatureSet(unsigned, H225_FeatureSet &) const;
    
    virtual void OnReceiveFeatureSet(unsigned, const H225_FeatureSet &) const;

#if OPAL_H450

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

#if OPAL_H460

    virtual H460_FeatureSet * GetFeatureSet();

    void H46019SetCallReceiver();

    void H46019Enabled();

    virtual PBoolean OnReceiveOLCGenericInformation(
      unsigned sessionID,
      const H245_ArrayOf_GenericInformation & alternate
    ) const;

   virtual PBoolean OnSendingOLCGenericInformation(
     const unsigned & sessionID,              
     H245_ArrayOf_GenericInformation & gen,   
     PBoolean isAck
   ) const;
#endif
    
#if OPAL_H460_NAT
    virtual PUDPSocket * GetNatSocket(unsigned session, PBoolean rtp);

    virtual void SetRTPNAT(unsigned sessionid, PUDPSocket * _rtp, PUDPSocket * _rtcp);


    class SessionInformation : public PObject
    {
      public:
        SessionInformation(const OpalGloballyUniqueID & id, const PString & token, unsigned session);

        const PString & GetCallToken();

        unsigned GetSessionID() const;

        const OpalGloballyUniqueID & GetCallIdentifer();

        const PString & GetCUI();

      protected:
        OpalGloballyUniqueID m_callID;
        PString              m_callToken;
        unsigned             m_sessionID;
        PString              m_CUI;
    };

    SessionInformation * BuildSessionInformation(unsigned sessionID) const;

    struct NAT_Sockets 
    {
        PUDPSocket * rtp;
        PUDPSocket * rtcp;
    };
#endif // OPAL_H460_NAT


    virtual bool OnMediaCommand(
      OpalMediaStream & stream,         
      const OpalMediaCommand & command  
    );

    enum CompatibilityIssues {
      e_NoMultipleTunnelledH245, 
      e_BadMasterSlaveConflict,  
      e_NoUserInputCapability,   
      NumCompatibilityIssues
    };

    bool HasCompatibilityIssue(
      CompatibilityIssues issue
    ) const;

    PBoolean StartHandleControlChannel();
    virtual PBoolean OnStartHandleControlChannel();
    void EndHandleControlChannel();
 
  protected:
    virtual void InternalEstablishedConnectionCheck();
    PBoolean InternalEndSessionCheck(PPER_Stream & strm);
    void SetRemoteVersions(const H225_ProtocolIdentifier & id);
    void SetBearerCapabilities(H323SignalPDU & pdu) const;
    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       transmitterSidePaused;
    bool       remoteTransmitPaused;
    bool       earlyStart;
    PString    t38ModeChangeCapabilities;
    PSyncPoint digitsWaitFlag;
    bool       endSessionSent;
    bool       endSessionNeeded;
    PSyncPoint endSessionReceived;
    PTimer     enforcedDurationLimit;
    bool       isConsultationTransfer;

    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
    bool disableH460;
    H460_FeatureSet * features;

    bool m_H46019CallReceiver;
    bool m_H46019enabled;
    bool m_h245Connect;

    bool m_H46024Aenabled;
    bool m_H46024Ainitator;
    PINDEX m_H46024Astate;

    bool m_H46024Benabled;
    PINDEX m_H46024Bstate;
#endif

#if OPAL_VIDEO
    PSimpleTimer m_h245FastUpdatePictureTimer;
#endif

#if OPAL_H460_NAT
    PMutex NATSocketMutex;
    std::map<unsigned, NAT_Sockets> m_NATSockets;
#endif // OPAL_H460_NAT

  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