home *** CD-ROM | disk | FTP | other *** search
/ ftp.muug.mb.ca / 2014.06.ftp.muug.mb.ca.tar / ftp.muug.mb.ca / pub / openh323.tar.gz / openh323.tar / openh323 / include / h323con.h < prev    next >
Text File  |  2003-04-29  |  91KB  |  2,339 lines
  1. /*
  2.  * h323con.h
  3.  *
  4.  * H.323 protocol handler
  5.  *
  6.  * Open H323 Library
  7.  *
  8.  * Copyright (c) 1998-2001 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Open H323 Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions of this code were written with the assisance of funding from
  25.  * Vovida Networks, Inc. http://www.vovida.com.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: h323con.h,v $
  30.  * Revision 1.60  2003/04/30 00:28:50  robertj
  31.  * Redesigned the alternate credentials in ARQ system as old implementation
  32.  *   was fraught with concurrency issues, most importantly it can cause false
  33.  *   detection of replay attacks taking out an endpoint completely.
  34.  *
  35.  * Revision 1.59  2003/02/12 23:59:22  robertj
  36.  * Fixed adding missing endpoint identifer in SETUP packet when gatekeeper
  37.  * routed, pointed out by Stefan Klein
  38.  * Also fixed correct rutrn of gk routing in IRR packet.
  39.  *
  40.  * Revision 1.58  2002/11/27 06:54:52  robertj
  41.  * Added Service Control Session management as per Annex K/H.323 via RAS
  42.  *   only at this stage.
  43.  * Added H.248 ASN and very primitive infrastructure for linking into the
  44.  *   Service Control Session management system.
  45.  * Added basic infrastructure for Annex K/H.323 HTTP transport system.
  46.  * Added Call Credit Service Control to display account balances.
  47.  *
  48.  * Revision 1.57  2002/11/15 05:17:22  robertj
  49.  * Added facility redirect support without changing the call token for access
  50.  *   to the call. If it gets redirected a new H323Connection object is
  51.  *   created but it looks like the same thing to an application.
  52.  *
  53.  * Revision 1.56  2002/11/13 04:37:23  robertj
  54.  * Added ability to get (and set) Q.931 release complete cause codes.
  55.  *
  56.  * Revision 1.55  2002/11/10 06:17:26  robertj
  57.  * Fixed minor documentation errors.
  58.  *
  59.  * Revision 1.54  2002/11/05 00:24:09  robertj
  60.  * Added function to determine if Q.931 CONNECT sent/received.
  61.  *
  62.  * Revision 1.53  2002/10/31 00:31:47  robertj
  63.  * Enhanced jitter buffer system so operates dynamically between minimum and
  64.  *   maximum values. Altered API to assure app writers note the change!
  65.  *
  66.  * Revision 1.52  2002/09/16 01:14:15  robertj
  67.  * Added #define so can select if #pragma interface/implementation is used on
  68.  *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
  69.  *
  70.  * Revision 1.51  2002/09/03 06:19:36  robertj
  71.  * Normalised the multi-include header prevention ifdef/define symbol.
  72.  *
  73.  * Revision 1.50  2002/08/05 10:03:47  robertj
  74.  * Cosmetic changes to normalise the usage of pragma interface/implementation.
  75.  *
  76.  * Revision 1.49  2002/08/05 05:17:37  robertj
  77.  * Fairly major modifications to support different authentication credentials
  78.  *   in ARQ to the logged in ones on RRQ. For both client and server.
  79.  * Various other H.235 authentication bugs and anomalies fixed on the way.
  80.  *
  81.  * Revision 1.48  2002/07/05 02:22:56  robertj
  82.  * Added support for standard and non-standard T.38 mode change.
  83.  *
  84.  * Revision 1.47  2002/07/04 00:40:31  robertj
  85.  * More H.450.11 call intrusion implementation, thanks Aleksandar Todorovic
  86.  *
  87.  * Revision 1.46  2002/06/22 06:11:30  robertj
  88.  * Fixed bug on sometimes missing received endSession causing 10 second
  89.  *   timeout in connection clean up.
  90.  *
  91.  * Revision 1.45  2002/06/22 05:48:38  robertj
  92.  * Added partial implementation for H.450.11 Call Intrusion
  93.  *
  94.  * Revision 1.44  2002/06/13 06:15:19  robertj
  95.  * Allowed TransferCall() to be used on H323Connection as well as H323EndPoint.
  96.  *
  97.  * Revision 1.43  2002/06/05 08:58:58  robertj
  98.  * Fixed documentation of remote application name string.
  99.  * Added missing virtual keywards on some protocol handler functions.
  100.  *
  101.  * Revision 1.42  2002/05/29 06:40:29  robertj
  102.  * Changed sending of endSession/ReleaseComplete PDU's to occur immediately
  103.  *   on call clearance and not wait for background thread to do it.
  104.  * Stricter compliance by waiting for reply endSession before closing down.
  105.  *
  106.  * Revision 1.41  2002/05/29 03:55:17  robertj
  107.  * Added protocol version number checking infrastructure, primarily to improve
  108.  *   interoperability with stacks that are unforgiving of new features.
  109.  *
  110.  * Revision 1.40  2002/05/21 09:32:49  robertj
  111.  * Added ability to set multiple alias names ona  connection by connection
  112.  *   basis, defaults to endpoint list, thanks Artis Kugevics
  113.  *
  114.  * Revision 1.39  2002/05/15 23:59:33  robertj
  115.  * Added memory management of created T.38 and T.120 handlers.
  116.  * Improved documentation for use of T.38 and T.120 functions.
  117.  * Added ability to initiate a mode change for non-standard T.38
  118.  *
  119.  * Revision 1.38  2002/05/07 01:31:51  dereks
  120.  * Fix typo in documentation.
  121.  *
  122.  * Revision 1.37  2002/05/03 05:38:15  robertj
  123.  * Added Q.931 Keypad IE mechanism for user indications (DTMF).
  124.  *
  125.  * Revision 1.36  2002/05/02 07:56:24  robertj
  126.  * Added automatic clearing of call if no media (RTP data) is transferred in a
  127.  *   configurable (default 5 minutes) amount of time.
  128.  *
  129.  * Revision 1.35  2002/04/25 20:55:25  dereks
  130.  * Fix documentation. Thanks Olaf Schulz.
  131.  *
  132.  * Revision 1.34  2002/04/17 00:50:34  robertj
  133.  * Added ability to disable the in band DTMF detection.
  134.  *
  135.  * Revision 1.33  2002/03/27 06:04:42  robertj
  136.  * Added Temporary Failure end code for connection, an application may
  137.  *   immediately retry the call if this occurs.
  138.  *
  139.  * Revision 1.32  2002/02/11 04:20:48  robertj
  140.  * Fixed documentation errors, thanks Horacio J. Pe±a
  141.  *
  142.  * Revision 1.31  2002/02/11 04:16:37  robertj
  143.  * Fixed bug where could send DRQ if never received an ACF.
  144.  *
  145.  * Revision 1.30  2002/02/06 06:30:47  craigs
  146.  * Fixed problem whereby MSD/TCS was stalled if H245 was included in
  147.  * SETUP, but other end did not respond
  148.  *
  149.  * Revision 1.29  2002/02/04 07:17:52  robertj
  150.  * Added H.450.2 Consultation Transfer, thanks Norwood Systems.
  151.  *
  152.  * Revision 1.28  2002/01/25 05:20:05  robertj
  153.  * Moved static strings for enum printing to inside of function, could crash with DLL's
  154.  *
  155.  * Revision 1.27  2002/01/24 06:29:02  robertj
  156.  * Added option to disable H.245 negotiation in SETUP pdu, this required
  157.  *   API change so have a bit mask instead of a series of booleans.
  158.  *
  159.  * Revision 1.26  2002/01/23 12:45:37  rogerh
  160.  * Add the DTMF decoder. This identifies DTMF tones in an audio stream.
  161.  *
  162.  * Revision 1.25  2002/01/23 07:12:48  robertj
  163.  * Added hooks for in band DTMF detection. Now need the detector!
  164.  *
  165.  * Revision 1.24  2002/01/22 22:48:21  robertj
  166.  * Fixed RFC2833 support (transmitter) requiring large rewrite
  167.  *
  168.  * Revision 1.23  2002/01/18 06:02:08  robertj
  169.  * Added some H323v4 functions (fastConnectRefused & TCS in SETUP)
  170.  *
  171.  * Revision 1.22  2002/01/17 07:04:58  robertj
  172.  * Added support for RFC2833 embedded DTMF in the RTP stream.
  173.  *
  174.  * Revision 1.21  2002/01/14 00:05:24  robertj
  175.  * Added H.450.6, better H.450.2 error handling and  and Music On Hold.
  176.  * Added destExtraCallInfo field for ARQ.
  177.  *   Thanks Ben Madsen of Norwood Systems
  178.  *
  179.  * Revision 1.20  2002/01/10 05:13:50  robertj
  180.  * Added support for external RTP stacks, thanks NuMind Software Systems.
  181.  *
  182.  * Revision 1.19  2002/01/09 00:21:36  robertj
  183.  * Changes to support outgoing H.245 RequstModeChange.
  184.  *
  185.  * Revision 1.18  2001/12/22 03:20:31  robertj
  186.  * Added create protocol function to H323Connection.
  187.  *
  188.  * Revision 1.17  2001/12/22 03:09:36  robertj
  189.  * Changed OnRequstModeChange to return ack, then actually do the change.
  190.  *
  191.  * Revision 1.16  2001/12/22 01:52:54  robertj
  192.  * Added more support for H.245 RequestMode operation.
  193.  *
  194.  * Revision 1.15  2001/12/15 08:09:54  robertj
  195.  * Added alerting, connect and end of call times to be sent to RAS server.
  196.  *
  197.  * Revision 1.14  2001/12/13 10:54:23  robertj
  198.  * Added ability to automatically add ACF access token to SETUP pdu.
  199.  *
  200.  * Revision 1.13  2001/11/01 06:11:54  robertj
  201.  * Plugged very small mutex hole that could cause crashes.
  202.  *
  203.  * Revision 1.12  2001/11/01 00:27:33  robertj
  204.  * Added default Fast Start disabled and H.245 tunneling disable flags
  205.  *   to the endpoint instance.
  206.  *
  207.  * Revision 1.11  2001/10/24 00:54:13  robertj
  208.  * Made cosmetic changes to H.245 miscellaneous command function.
  209.  *
  210.  * Revision 1.10  2001/10/23 02:18:06  dereks
  211.  * Initial release of CU30 video codec.
  212.  *
  213.  * Revision 1.9  2001/09/26 06:20:56  robertj
  214.  * Fixed properly nesting connection locking and unlocking requiring a quite
  215.  *   large change to teh implementation of how calls are answered.
  216.  *
  217.  * Revision 1.8  2001/09/19 03:30:53  robertj
  218.  * Added some support for overlapped dialing, thanks Chris Purvis & Nick Hoath.
  219.  *
  220.  * Revision 1.7  2001/09/13 06:48:13  robertj
  221.  * Added call back functions for remaining Q.931/H.225 messages.
  222.  * Added call back to allow modification of Release Complete,thanks Nick Hoath
  223.  *
  224.  * Revision 1.6  2001/09/12 06:57:58  robertj
  225.  * Added support for iNow Access Token from gk, thanks Nick Hoath
  226.  *
  227.  * Revision 1.5  2001/09/12 06:04:36  robertj
  228.  * Added support for sending UUIE's to gk on request, thanks Nick Hoath
  229.  *
  230.  * Revision 1.4  2001/09/11 01:24:36  robertj
  231.  * Added conditional compilation to remove video and/or audio codecs.
  232.  *
  233.  * Revision 1.3  2001/08/22 06:54:50  robertj
  234.  * Changed connection locking to use double mutex to guarantee that
  235.  *   no threads can ever deadlock or access deleted connection.
  236.  *
  237.  * Revision 1.2  2001/08/16 07:49:16  robertj
  238.  * Changed the H.450 support to be more extensible. Protocol handlers
  239.  *   are now in separate classes instead of all in H323Connection.
  240.  *
  241.  * Revision 1.1  2001/08/06 03:08:11  robertj
  242.  * Fission of h323.h to h323ep.h & h323con.h, h323.h now just includes files.
  243.  *
  244.  */
  245.  
  246. #ifndef __OPAL_H323CON_H
  247. #define __OPAL_H323CON_H
  248.  
  249. #ifdef P_USE_PRAGMA
  250. #pragma interface
  251. #endif
  252.  
  253.  
  254. #include <ptclib/dtmf.h>
  255. #include "h323caps.h"
  256. #include "transports.h"
  257. #include "channels.h"
  258. #include "guid.h"
  259.  
  260.  
  261. /* The following classes have forward references to avoid including the VERY
  262.    large header files for H225 and H245. If an application requires access
  263.    to the protocol classes they can include them, but for simple usage their
  264.    inclusion can be avoided.
  265.  */
  266. class PPER_Stream;
  267.  
  268. class H225_EndpointType;
  269. class H225_TransportAddress;
  270. class H225_ArrayOf_PASN_OctetString;
  271. class H225_ProtocolIdentifier;
  272. class H225_AdmissionRequest;
  273.  
  274. class H245_TerminalCapabilitySet;
  275. class H245_TerminalCapabilitySetReject;
  276. class H245_OpenLogicalChannel;
  277. class H245_OpenLogicalChannelAck;
  278. class H245_TransportAddress;
  279. class H245_UserInputIndication;
  280. class H245_RequestMode;
  281. class H245_RequestModeAck;
  282. class H245_RequestModeReject;
  283. class H245_ModeDescription;
  284. class H245_ArrayOf_ModeDescription;
  285. class H245_SendTerminalCapabilitySet;
  286. class H245_MultiplexCapability;
  287. class H245_FlowControlCommand;
  288. class H245_MiscellaneousCommand;
  289. class H245_MiscellaneousIndication;
  290. class H245_JitterIndication;
  291.  
  292. class H323SignalPDU;
  293. class H323ControlPDU;
  294.  
  295. class H235Authenticators;
  296.  
  297. class H245NegMasterSlaveDetermination;
  298. class H245NegTerminalCapabilitySet;
  299. class H245NegLogicalChannels;
  300. class H245NegRequestMode;
  301. class H245NegRoundTripDelay;
  302.  
  303. class H450xDispatcher;
  304. class H4502Handler;
  305. class H4504Handler;
  306. class H4506Handler;
  307. class H45011Handler;
  308.  
  309. class OpalT120Protocol;
  310. class OpalT38Protocol;
  311. class OpalRFC2833;
  312. class OpalRFC2833Info;
  313.  
  314.  
  315.  
  316. ///////////////////////////////////////////////////////////////////////////////
  317.  
  318. /**This class represents a particular H323 connection between two endpoints.
  319.    There are at least two threads in use, this one to look after the
  320.    signalling channel, an another to look after the control channel. There
  321.    would then be additional threads created for each data channel created by
  322.    the control channel protocol thread.
  323.  */
  324. class H323Connection : public PObject
  325. {
  326.   PCLASSINFO(H323Connection, PObject);
  327.  
  328.   public:
  329.   /**@name Construction */
  330.   //@{
  331.     enum Options {
  332.       FastStartOptionDisable       = 0x0001,
  333.       FastStartOptionEnable        = 0x0002,
  334.       FastStartOptionMask          = 0x0003,
  335.  
  336.       H245TunnelingOptionDisable   = 0x0004,
  337.       H245TunnelingOptionEnable    = 0x0008,
  338.       H245TunnelingOptionMask      = 0x000c,
  339.  
  340.       H245inSetupOptionDisable     = 0x0010,
  341.       H245inSetupOptionEnable      = 0x0020,
  342.       H245inSetupOptionMask        = 0x0030,
  343.  
  344.       DetectInBandDTMFOptionDisable= 0x0040,
  345.       DetectInBandDTMFOptionEnable = 0x0080,
  346.       DetectInBandDTMFOptionMask   = 0x00c0,
  347.     };
  348.  
  349.     /**Create a new connection.
  350.      */
  351.     H323Connection(
  352.       H323EndPoint & endpoint,  /// H323 End Point object
  353.       unsigned callReference,   /// Call reference
  354.       unsigned options = 0      /// Connection option bits
  355.     );
  356.  
  357.     /**Destroy the connection
  358.      */
  359.     ~H323Connection();
  360.  
  361.     /**Lock connection.
  362.        When any thread wants exclusive use of the connection, it must use this
  363.        function to gain the mutex. Note this is not a simple mutex to allow
  364.        for the rather complicated mechanism for preventing deadlocks in
  365.        associated threads to the connection (eg Q.931 reader thread).
  366.  
  367.        Returns FALSE if the lock was not obtainable due to the connection being
  368.        shut down.
  369.      */
  370.     BOOL Lock();
  371.  
  372.     /**Try to lock connection.
  373.        When the H323EndPoint::FindConnectionWithLock() function is used to gain
  374.        access to a connection object, this is called to prevent it from being
  375.        closed and deleted by the background threads.
  376.  
  377.        Note this is an internal function and it is not expected an application
  378.        would use it.
  379.  
  380.        Returns 0 if the lock was not obtainable due to the connection being
  381.        shut down, -1 if it was not available, and +1 if lock is obtained.
  382.      */
  383.     int TryLock();
  384.  
  385.     /**Unlock connection.
  386.        If the H323EndPoint::FindConnectionWithLock() function is used to gain
  387.        access to a connection object, this MUST be called to allow it to
  388.        subsequently be closed and disposed of.
  389.      */
  390.     void Unlock();
  391.  
  392.     /** Called when a connection is established.
  393.         Default behaviour is to call H323EndPoint::OnConnectionEstablished
  394.       */
  395.     virtual void OnEstablished();
  396.  
  397.     /** Called when a connection is cleared, just after CleanUpOnCallEnd()
  398.         Default behaviour is to call H323EndPoint::OnConnectionCleared
  399.       */
  400.     virtual void OnCleared();
  401.  
  402.     /**Determine if the call has been connected.
  403.        This indicates that Q.931 CONNECT has occurred. This usually means in
  404.        PSTN gateway environments that a charge will be made for the call. This
  405.        is not quite the same as IsEstablished() as that indicates the call is
  406.        connected AND there is media open.
  407.       */
  408.     BOOL IsConnected() const { return connectionState == HasExecutedSignalConnect || connectionState == EstablishedConnection; }
  409.  
  410.     /**Determine if the call has been established.
  411.        This can be used in combination with the GetCallEndReason() function
  412.        to determine the three main phases of a call, call setup, call
  413.        established and call cleared.
  414.       */
  415.     BOOL IsEstablished() const { return connectionState == EstablishedConnection; }
  416.  
  417.     /**Call clearance reasons.
  418.        NOTE: if anything is added to this, you also need to add the field to
  419.        the tables in h323.cxx and h323pdu.cxx.
  420.       */
  421.     enum CallEndReason {
  422.       EndedByLocalUser,         /// Local endpoint application cleared call
  423.       EndedByNoAccept,          /// Local endpoint did not accept call OnIncomingCall()=FALSE
  424.       EndedByAnswerDenied,      /// Local endpoint declined to answer call
  425.       EndedByRemoteUser,        /// Remote endpoint application cleared call
  426.       EndedByRefusal,           /// Remote endpoint refused call
  427.       EndedByNoAnswer,          /// Remote endpoint did not answer in required time
  428.       EndedByCallerAbort,       /// Remote endpoint stopped calling
  429.       EndedByTransportFail,     /// Transport error cleared call
  430.       EndedByConnectFail,       /// Transport connection failed to establish call
  431.       EndedByGatekeeper,        /// Gatekeeper has cleared call
  432.       EndedByNoUser,            /// Call failed as could not find user (in GK)
  433.       EndedByNoBandwidth,       /// Call failed as could not get enough bandwidth
  434.       EndedByCapabilityExchange,/// Could not find common capabilities
  435.       EndedByCallForwarded,     /// Call was forwarded using FACILITY message
  436.       EndedBySecurityDenial,    /// Call failed a security check and was ended
  437.       EndedByLocalBusy,         /// Local endpoint busy
  438.       EndedByLocalCongestion,   /// Local endpoint congested
  439.       EndedByRemoteBusy,        /// Remote endpoint busy
  440.       EndedByRemoteCongestion,  /// Remote endpoint congested
  441.       EndedByUnreachable,       /// Could not reach the remote party
  442.       EndedByNoEndPoint,        /// The remote party is not running an endpoint
  443.       EndedByHostOffline,       /// The remote party host off line
  444.       EndedByTemporaryFailure,  /// The remote failed temporarily app may retry
  445.       EndedByQ931Cause,         /// The remote ended the call with unmapped Q.931 cause code
  446.       EndedByDurationLimit,     /// Call cleared due to an enforced duration limit
  447.       NumCallEndReasons
  448.     };
  449. #if PTRACING
  450.     friend ostream & operator<<(ostream & o, CallEndReason r);
  451. #endif
  452.  
  453.     /**Get the call clearand reason for this connection shutting down.
  454.        Note that this function is only generally useful in the
  455.        H323EndPoint::OnConnectionCleared() function. This is due to the
  456.        connection not being cleared before that, and the object not even
  457.        exiting after that.
  458.  
  459.        If the call is still active then this will return NumCallEndReasons.
  460.       */
  461.     CallEndReason GetCallEndReason() const { return callEndReason; }
  462.  
  463.     /**Set the call clearance reason.
  464.        An application should have no cause to use this function. It is present
  465.        for the H323EndPoint::ClearCall() function to set the clearance reason.
  466.       */
  467.     virtual void SetCallEndReason(
  468.       CallEndReason reason,     /// Reason for clearance of connection.
  469.       PSyncPoint * sync = NULL  /// syncpoint to use for synchronous destruction
  470.     );
  471.  
  472.     /**Clear a current connection.
  473.        This hangs up the connection to a remote endpoint. It actually just
  474.        calls the endpoint version of the ClearCall() function to avoid
  475.        possible multithreading race conditions.
  476.       */
  477.     virtual BOOL ClearCall(
  478.       CallEndReason reason = EndedByLocalUser  /// Reason for call clearing
  479.     );
  480.  
  481.     /**Clear a current connection, synchronously
  482.       */
  483.     virtual BOOL ClearCallSynchronous(
  484.       PSyncPoint * sync,
  485.       CallEndReason reason = EndedByLocalUser  /// Reason for call clearing
  486.     );
  487.  
  488.     /**Clean up the call clearance of the connection.
  489.        This function will do any internal cleaning up and waiting on background
  490.        threads that may be using the connection object. After this returns it
  491.        is then safe to delete the object.
  492.  
  493.        An application will not typically use this function as it is used by the
  494.        H323EndPoint during a clear call.
  495.       */
  496.     virtual void CleanUpOnCallEnd();
  497.   //@}
  498.  
  499.  
  500.   /**@name Signalling Channel */
  501.   //@{
  502.     /**Attach a transport to this connection as the signalling channel.
  503.       */
  504.     void AttachSignalChannel(
  505.       const PString & token,    /// New token to use to identify connection
  506.       H323Transport * channel,  /// Transport for the PDU's
  507.       BOOL answeringCall        /// Flag for if incoming/outgoing call.
  508.     );
  509.  
  510.     /**Write a PDU to the signalling channel.
  511.       */
  512.     BOOL WriteSignalPDU(
  513.       H323SignalPDU & pdu       /// PDU to write.
  514.     );
  515.  
  516.     /**Handle reading PDU's from the signalling channel.
  517.        This is an internal function and is unlikely to be used by applications.
  518.      */
  519.     virtual void HandleSignallingChannel();
  520.  
  521.     /**Handle PDU from the signalling channel.
  522.        This is an internal function and is unlikely to be used by applications.
  523.      */
  524.     virtual BOOL HandleSignalPDU(
  525.       H323SignalPDU & pdu       /// PDU to handle.
  526.     );
  527.  
  528.     /**Handle Control PDU tunnelled in the signalling channel.
  529.        This is an internal function and is unlikely to be used by applications.
  530.      */
  531.     virtual void HandleTunnelPDU(
  532.       H323SignalPDU * txPDU       /// PDU tunnel response into.
  533.     );
  534.  
  535.     /**Handle an incoming Q931 setup PDU.
  536.        The default behaviour is to do the handshaking operation calling a few
  537.        virtuals at certain moments in the sequence.
  538.  
  539.        If FALSE is returned the connection is aborted and a Release Complete
  540.        PDU is sent.
  541.      */
  542.     virtual BOOL OnReceivedSignalSetup(
  543.       const H323SignalPDU & pdu   /// Received setup PDU
  544.     );
  545.  
  546.     /**Handle an incoming Q931 setup acknowledge PDU.
  547.        If FALSE is returned the connection is aborted and a Release Complete
  548.        PDU is sent.
  549.  
  550.        The default behaviour does nothing.
  551.      */
  552.     virtual BOOL OnReceivedSignalSetupAck(
  553.       const H323SignalPDU & pdu   /// Received setup PDU
  554.     );
  555.  
  556.     /**Handle an incoming Q931 information PDU.
  557.        If FALSE is returned the connection is aborted and a Release Complete
  558.        PDU is sent.
  559.  
  560.        The default behaviour does nothing.
  561.      */
  562.     virtual BOOL OnReceivedSignalInformation(
  563.       const H323SignalPDU & pdu   /// Received setup PDU
  564.     );
  565.  
  566.     /**Handle an incoming Q931 call proceeding PDU.
  567.        If FALSE is returned the connection is aborted and a Release Complete
  568.        PDU is sent.
  569.  
  570.        The default behaviour checks for hH245Address field and if present
  571.        starts the separate H245 channel, if successful or not present it
  572.        returns TRUE.
  573.      */
  574.     virtual BOOL OnReceivedCallProceeding(
  575.       const H323SignalPDU & pdu   /// Received call proceeding PDU
  576.     );
  577.  
  578.     /**Handle an incoming Q931 progress PDU.
  579.        If FALSE is returned the connection is aborted and a Release Complete
  580.        PDU is sent.
  581.  
  582.        The default behaviour checks for hH245Address field and if present
  583.        starts the separate H245 channel, if successful or not present it
  584.        returns TRUE.
  585.      */
  586.     virtual BOOL OnReceivedProgress(
  587.       const H323SignalPDU & pdu   /// Received call proceeding PDU
  588.     );
  589.  
  590.     /**Handle an incoming Q931 alerting PDU.
  591.        If FALSE is returned the connection is aborted and a Release Complete
  592.        PDU is sent.
  593.  
  594.        The default behaviour obtains the display name and calls OnAlerting().
  595.      */
  596.     virtual BOOL OnReceivedAlerting(
  597.       const H323SignalPDU & pdu   /// Received connect PDU
  598.     );
  599.  
  600.     /**Handle an incoming Q931 connect PDU.
  601.        If FALSE is returned the connection is aborted and a Release Complete
  602.        PDU is sent.
  603.  
  604.        The default behaviour checks for hH245Address field and if present
  605.        starts the separate H245 channel, if successful it returns TRUE.
  606.        If not present and there is no H245Tunneling then it returns FALSE.
  607.      */
  608.     virtual BOOL OnReceivedSignalConnect(
  609.       const H323SignalPDU & pdu   /// Received connect PDU
  610.     );
  611.  
  612.     /**Handle an incoming Q931 facility PDU.
  613.        If FALSE is returned the connection is aborted and a Release Complete
  614.        PDU is sent.
  615.  
  616.        The default behaviour checks for hH245Address field and if present
  617.        starts the separate H245 channel, if successful or not present it
  618.        returns TRUE.
  619.      */
  620.     virtual BOOL OnReceivedFacility(
  621.       const H323SignalPDU & pdu   /// Received connect PDU
  622.     );
  623.  
  624.     /**Handle an incoming Q931 Notify PDU.
  625.        If FALSE is returned the connection is aborted and a Release Complete
  626.        PDU is sent.
  627.  
  628.        The default behaviour simply returns TRUE.
  629.      */
  630.     virtual BOOL OnReceivedSignalNotify(
  631.       const H323SignalPDU & pdu   /// Received connect PDU
  632.     );
  633.  
  634.     /**Handle an incoming Q931 Status PDU.
  635.        If FALSE is returned the connection is aborted and a Release Complete
  636.        PDU is sent.
  637.  
  638.        The default behaviour simply returns TRUE.
  639.      */
  640.     virtual BOOL OnReceivedSignalStatus(
  641.       const H323SignalPDU & pdu   /// Received connect PDU
  642.     );
  643.  
  644.     /**Handle an incoming Q931 Status Enquiry PDU.
  645.        If FALSE is returned the connection is aborted and a Release Complete
  646.        PDU is sent.
  647.  
  648.        The default behaviour sends a Q931 Status PDU back.
  649.      */
  650.     virtual BOOL OnReceivedStatusEnquiry(
  651.       const H323SignalPDU & pdu   /// Received connect PDU
  652.     );
  653.  
  654.     /**Handle an incoming Q931 Release Complete PDU.
  655.        The default behaviour calls Clear() using reason code based on the
  656.        Release Complete Cause field and the current connection state.
  657.      */
  658.     virtual void OnReceivedReleaseComplete(
  659.       const H323SignalPDU & pdu   /// Received connect PDU
  660.     );
  661.  
  662.     /**This function is called from the HandleSignallingChannel() function
  663.        for unhandled PDU types.
  664.  
  665.        If FALSE is returned the connection is aborted and a Release Complete
  666.        PDU is sent. The default behaviour returns TRUE.
  667.      */
  668.     virtual BOOL OnUnknownSignalPDU(
  669.       const H323SignalPDU & pdu  /// Received PDU
  670.     );
  671.  
  672.     /**Call back for incoming call.
  673.        This function is called from the OnReceivedSignalSetup() function
  674.        before it sends the Alerting PDU. It gives an opportunity for an
  675.        application to alter the reply before transmission to the other
  676.        endpoint.
  677.  
  678.        If FALSE is returned the connection is aborted and a Release Complete
  679.        PDU is sent.
  680.  
  681.        The default behaviour calls the endpoint function of the same name.
  682.      */
  683.     virtual BOOL OnIncomingCall(
  684.       const H323SignalPDU & setupPDU,   /// Received setup PDU
  685.       H323SignalPDU & alertingPDU       /// Alerting PDU to send
  686.     );
  687.  
  688.     /**Forward incoming call to specified address.
  689.        This would typically be called from within the OnIncomingCall()
  690.        function when an application wishes to redirct an unwanted incoming
  691.        call.
  692.  
  693.        The return value is TRUE if the call is to be forwarded, FALSE
  694.        otherwise. Note that if the call is forwarded the current connection is
  695.        cleared with the ended call code of EndedByCallForwarded.
  696.       */
  697.     virtual BOOL ForwardCall(
  698.       const PString & forwardParty   /// Party to forward call to.
  699.     );
  700.  
  701.     /**Initiate the transfer of an existing call (connection) to a new remote party
  702.        using H.450.2.  This sends a Call Transfer Initiate Invoke message from the
  703.        A-Party (transferring endpoint) to the B-Party (transferred endpoint).
  704.      */
  705.     void TransferCall(
  706.       const PString & remoteParty,   /// Remote party to transfer the existing call to
  707.       const PString & callIdentity = PString::Empty()
  708.                                     /// Call Identity of secondary call if present
  709.     );
  710.  
  711.     /**Transfer the call through consultation so the remote party in the primary call is connected to
  712.        the called party in the second call using H.450.2.  This sends a Call Transfer Identify Invoke 
  713.        message from the A-Party (transferring endpoint) to the C-Party (transferred-to endpoint).
  714.      */
  715.     void ConsultationTransfer(
  716.       const PString & primaryCallToken  /// Primary call
  717.     );
  718.  
  719.     /**Handle the reception of a callTransferSetupInvoke APDU whilst a secondary call exists.  This 
  720.        method checks whether the secondary call is still waiting for a callTransferSetupInvoke APDU and 
  721.        proceeds to clear the call if the call identies match.
  722.        This is an internal function and it is not expected the user will call
  723.        it directly.
  724.      */
  725.     virtual void HandleConsultationTransfer(
  726.       const PString & callIdentity, /**Call Identity of secondary call 
  727.                                        received in SETUP Message. */
  728.       H323Connection & incoming     /// Connection upon which SETUP PDU was received.
  729.     );
  730.  
  731.     /**Determine whether this connection is being transferred.
  732.      */
  733.     BOOL IsTransferringCall() const;
  734.  
  735.     /**Determine whether this connection is the result of a transferred call.
  736.      */
  737.     BOOL IsTransferredCall() const;
  738.  
  739.     /**Handle the transfer of an existing connection to a new remote.
  740.        This is an internal function and it is not expected the user will call
  741.        it directly.
  742.      */
  743.     virtual void HandleTransferCall(
  744.       const PString & token,
  745.       const PString & identity
  746.     );
  747.  
  748.     /**Get transfer invoke ID dureing trasfer.
  749.        This is an internal function and it is not expected the user will call
  750.        it directly.
  751.       */
  752.     int GetCallTransferInvokeId();
  753.  
  754.     /**Handle the failure of a call transfer operation at the Transferred Endpoint.  This method is
  755.        used to handle the following transfer failure cases that can occur at the Transferred Endpoint. 
  756.        The cases are:
  757.        Reception of an Admission Reject
  758.        Reception of a callTransferSetup return error APDU.
  759.        Expiry of Call Transfer timer CT-T4.
  760.      */
  761.     virtual void HandleCallTransferFailure(
  762.       const int returnError    /// Failure reason code
  763.     );
  764.  
  765.     /**Store the passed token on the current connection's H4502Handler.
  766.        This is an internal function and it is not expected the user will call
  767.        it directly.
  768.      */
  769.     void SetAssociatedCallToken(
  770.       const PString & token  /// Associated token
  771.     );
  772.  
  773.     /**Callback to indicate a successful transfer through consultation.  The paramter passed is a
  774.        reference to the existing connection between the Transferring endpoint and Transferred-to 
  775.        endpoint.
  776.      */
  777.     virtual void OnConsultationTransferSuccess(
  778.       H323Connection & secondaryCall  /// Secondary call for consultation
  779.     );
  780.  
  781.     /**Place the call on hold, suspending all media channels (H.450.4).  Note it is the responsibility 
  782.        of the application layer to delete the MOH Channel if music on hold is provided to the remote
  783.        endpoint.  So far only Local Hold has been implemented. 
  784.      */
  785.     void HoldCall(
  786.       BOOL localHold   /// true for Local Hold, false for Remote Hold
  787.     );
  788.  
  789.     /**Retrieve the call from hold, activating all media channels (H.450.4).
  790.        This method examines the call hold state and performs the necessary
  791.        actions required to retrieve a Near-end or Remote-end call on hold.
  792.        NOTE: Only Local Hold is implemented so far. 
  793.     */
  794.     void RetrieveCall();
  795.  
  796.     /**Set the alternative media channel.  This channel can be used to provide
  797.        Media On Hold (MOH) for a near end call hold operation or to provide
  798.        Recorded Voice Anouncements (RVAs).  If this method is not called before
  799.        a call hold operation is attempted, no media on hold will be provided
  800.        for the held endpoint.
  801.       */
  802.     void SetHoldMedia(
  803.       PChannel * audioChannel
  804.     );
  805.  
  806.     /**Determine if Meadia On Hold is enabled.
  807.       */
  808.     BOOL IsMediaOnHold() const;
  809.  
  810.     /**Determine if held.
  811.       */
  812.     BOOL IsLocalHold() const;
  813.  
  814.     /**Determine if held.
  815.       */
  816.     BOOL IsRemoteHold() const;
  817.  
  818.     /**Determine if the current call is held or in the process of being held.
  819.       */
  820.     BOOL IsCallOnHold() const;
  821.  
  822.     /**Begin a call intrusion request.
  823.        Calls h45011handler->IntrudeCall where SS pdu is added to Call Setup
  824.        message.
  825.       */
  826.     virtual void IntrudeCall(
  827.       unsigned capabilityLevel
  828.     );
  829.  
  830.     /**Handle an incoming call instrusion request.
  831.        Calls h45011handler->AwaitSetupResponse where we set Handler state to
  832.        CI-Wait-Ack
  833.       */
  834.     virtual void HandleIntrudeCall(
  835.       const PString & token,
  836.       const PString & identity
  837.     );
  838.  
  839.     /**Set flag indicating call intrusion.
  840.        Used to set a flag when intrusion occurs and to determine if
  841.        connection is created for Call Intrusion. This flag is used when we
  842.        should decide whether to Answer the call or to Close it.
  843.       */
  844.     void SetCallIntrusion() { isCallIntrusion = TRUE; }
  845.  
  846.     BOOL IsCallIntrusion() { return isCallIntrusion; }
  847.  
  848.     /**Get Call Intrusion Protection Level of the local endpoint.
  849.       */
  850.     unsigned GetLocalCallIntrusionProtectionLevel() { return callIntrusionProtectionLevel; }
  851.  
  852.     /**Get Call Intrusion Protection Level of other endpoints that we are in
  853.        connection with.
  854.       */
  855.     virtual BOOL GetRemoteCallIntrusionProtectionLevel(
  856.       const PString & callToken,
  857.       unsigned callIntrusionProtectionLevel
  858.     );
  859.  
  860.     virtual void SetIntrusionImpending();
  861.  
  862.     virtual void SetForcedReleaseAccepted();
  863.  
  864.     virtual void SetIntrusionNotAuthorized();
  865.  
  866.     /**Send a Call Waiting indication message to the remote endpoint using
  867.        H.450.6.  The second paramter is used to indicate to the calling user
  868.        how many additional users are "camped on" the called user. A value of
  869.        zero indicates to the calling user that he/she is the only user
  870.        attempting to reach the busy called user.
  871.      */
  872.     void SendCallWaitingIndication(
  873.       const unsigned nbOfAddWaitingCalls = 0   /// number of additional waiting calls at the served user
  874.     );
  875.  
  876.     enum AnswerCallResponse {
  877.       AnswerCallNow,               /// Answer the call continuing with the connection.
  878.       AnswerCallDenied,            /// Refuse the call sending a release complete.
  879.       AnswerCallPending,           /// Send an Alerting PDU and wait for AnsweringCall()
  880.       AnswerCallDeferred,          /// As for AnswerCallPending but does not send Alerting PDU
  881.       AnswerCallAlertWithMedia,    /// As for AnswerCallPending but starts media channels
  882.       AnswerCallDeferredWithMedia, /// As for AnswerCallDeferred but starts media channels
  883.       NumAnswerCallResponses
  884.     };
  885. #if PTRACING
  886.     friend ostream & operator<<(ostream & o, AnswerCallResponse s);
  887. #endif
  888.  
  889.     /**Call back for answering an incoming call.
  890.        This function is used for an application to control the answering of
  891.        incoming calls. It is usually used to indicate the immediate action to
  892.        be taken in answering the call.
  893.  
  894.        It is called from the OnReceivedSignalSetup() function before it sends
  895.        the Alerting or Connect PDUs. It also gives an opportunity for an
  896.        application to alter the Connect PDU reply before transmission to the
  897.        remote endpoint.
  898.  
  899.        If AnswerCallNow is returned then the H.323 protocol proceeds with the
  900.        connection. If AnswerCallDenied is returned the connection is aborted
  901.        and a Release Complete PDU is sent. If AnswerCallPending is returned
  902.        then the Alerting PDU is sent and the protocol negotiations are paused
  903.        until the AnsweringCall() function is called. Finally, if
  904.        AnswerCallDeferred is returned then no Alerting PDU is sent, but the
  905.        system still waits as in the AnswerCallPending response.
  906.  
  907.        Note this function should not block for any length of time. If the
  908.        decision to answer the call may take some time eg waiting for a user to
  909.        pick up the phone, then AnswerCallPending or AnswerCallDeferred should
  910.        be returned.
  911.  
  912.        The default behaviour calls the endpoint function of the same name
  913.        which in turn will return AnswerCallNow.
  914.      */
  915.     virtual AnswerCallResponse OnAnswerCall(
  916.       const PString & callerName,       /// Name of caller
  917.       const H323SignalPDU & setupPDU,   /// Received setup PDU
  918.       H323SignalPDU & connectPDU        /// Connect PDU to send. 
  919.     );
  920.  
  921.     /**Indicate the result of answering an incoming call.
  922.        This should only be called if the OnAnswerCall() callback function has
  923.        returned a AnswerCallPending or AnswerCallDeferred response.
  924.  
  925.        Note sending further AnswerCallPending responses via this function will
  926.        have the result of an Alerting PDU being sent to the remote endpoint.
  927.        In this way multiple Alerting PDUs may be sent.
  928.  
  929.        Sending a AnswerCallDeferred response would have no effect.
  930.       */
  931.     void AnsweringCall(
  932.       AnswerCallResponse response /// Answer response to incoming call
  933.     );
  934.  
  935.     /**Send first PDU in signalling channel.
  936.        This function does the signalling handshaking for establishing a
  937.        connection to a remote endpoint. The transport (TCP/IP) for the
  938.        signalling channel is assumed to be already created. This function
  939.        will then do the SetRemoteAddress() and Connect() calls o establish
  940.        the transport.
  941.  
  942.        Returns the error code for the call failure reason or NumCallEndReasons
  943.        if the call was successful to that point in the protocol.
  944.      */
  945.     virtual CallEndReason SendSignalSetup(
  946.       const PString & alias,                /// Name of remote party
  947.       const H323TransportAddress & address  /// Address of destination
  948.     );
  949.  
  950.     /**Adjust setup PDU being sent on initialisation of signal channel.
  951.        This function is called from the SendSignalSetup() function before it
  952.        sends the Setup PDU. It gives an opportunity for an application to
  953.        alter the request before transmission to the other endpoint.
  954.  
  955.        The default behaviour simply returns TRUE. Note that this is usually
  956.        overridden by the transport dependent descendent class, eg the
  957.        H323ConnectionTCP descendent fills in the destCallSignalAddress field
  958.        with the TCP/IP data. Therefore if you override this in your
  959.        application make sure you call the ancestor function.
  960.      */
  961.     virtual BOOL OnSendSignalSetup(
  962.       H323SignalPDU & setupPDU   /// Setup PDU to send
  963.     );
  964.  
  965.     /**Adjust call proceeding PDU being sent. This function is called from
  966.        the OnReceivedSignalSetup() function before it sends the Call
  967.        Proceeding PDU. It gives an opportunity for an application to alter
  968.        the request before transmission to the other endpoint. If this function
  969.        returns FALSE then the Call Proceeding PDU is not sent at all.
  970.  
  971.        The default behaviour simply returns TRUE.
  972.      */
  973.     virtual BOOL OnSendCallProceeding(
  974.       H323SignalPDU & callProceedingPDU   /// Call Proceeding PDU to send
  975.     );
  976.  
  977.     /**Call back for Release Complete being sent.
  978.        This allows an application to add things to the release complete before
  979.        it is sent to the remote endpoint.
  980.  
  981.        Returning FALSE will prevent the release complete from being sent. Note
  982.        that this would be very unusual as this is called when the connection
  983.        is being cleaned up. There will be no second chance to send the PDU and
  984.        it must be sent.
  985.  
  986.        The default behaviour simply returns TRUE.
  987.       */
  988.     virtual BOOL OnSendReleaseComplete(
  989.       H323SignalPDU & releaseCompletePDU /// Release Complete PDU to send
  990.     );
  991.  
  992.     /**Call back for remote party being alerted.
  993.        This function is called from the SendSignalSetup() function after it
  994.        receives the optional Alerting PDU from the remote endpoint. That is
  995.        when the remote "phone" is "ringing".
  996.  
  997.        If FALSE is returned the connection is aborted and a Release Complete
  998.        PDU is sent.
  999.  
  1000.        The default behaviour calls the endpoint function of the same name.
  1001.      */
  1002.     virtual BOOL OnAlerting(
  1003.       const H323SignalPDU & alertingPDU,  /// Received Alerting PDU
  1004.       const PString & user                /// Username of remote endpoint
  1005.     );
  1006.  
  1007.     /**This function is called when insufficient digits have been entered.
  1008.        This supports overlapped dialling so that a call can begin when it is
  1009.        not known how many more digits are to be entered in a phone number.
  1010.  
  1011.        It is expected that the application will override this function. It
  1012.        should be noted that the application should not block in the function
  1013.        but only indicate to whatever other thread is gathering digits that
  1014.        more are required and that thread should call SendMoreDigits().
  1015.  
  1016.        If FALSE is returned the connection is aborted and a Release Complete
  1017.        PDU is sent.
  1018.  
  1019.        The default behaviour simply returns FALSE.
  1020.      */
  1021.     virtual BOOL OnInsufficientDigits();
  1022.  
  1023.     /**This function is called when sufficient digits have been entered.
  1024.        This supports overlapped dialling so that a call can begin when it is
  1025.        not known how many more digits are to be entered in a phone number.
  1026.  
  1027.        The digits parameter is appended to the existing remoteNumber member
  1028.        variable and the call is retried.
  1029.  
  1030.        If FALSE is returned the connection is aborted and a Release Complete
  1031.        PDU is sent.
  1032.  
  1033.        The default behaviour simply returns TRUE.
  1034.      */
  1035.     virtual void SendMoreDigits(
  1036.       const PString & digits    /// Extra digits
  1037.     );
  1038.  
  1039.     /**This function is called from the SendSignalSetup() function after it
  1040.        receives the Connect PDU from the remote endpoint, but before it
  1041.        attempts to open the control channel.
  1042.  
  1043.        If FALSE is returned the connection is aborted and a Release Complete
  1044.        PDU is sent.
  1045.  
  1046.        The default behaviour simply returns TRUE.
  1047.      */
  1048.     virtual BOOL OnOutgoingCall(
  1049.       const H323SignalPDU & connectPDU   /// Received Connect PDU
  1050.     );
  1051.  
  1052.     /**Send an the acknowldege of a fast start.
  1053.        This function is called when the fast start channels provided to this
  1054.        connection by the original SETUP PDU have been selected and opened and
  1055.        need to be sent back to the remote endpoint.
  1056.  
  1057.        If FALSE is returned then no fast start has been acknowledged, possibly
  1058.        due to no common codec in fast start request.
  1059.  
  1060.        The default behaviour uses OnSelectLogicalChannels() to find a pair of
  1061.        channels and adds then to the provided PDU.
  1062.      */
  1063.     virtual BOOL SendFastStartAcknowledge(
  1064.       H225_ArrayOf_PASN_OctetString & array   /// Array of H245_OpenLogicalChannel
  1065.     );
  1066.  
  1067.     /**Handle the acknowldege of a fast start.
  1068.        This function is called from one of a number of functions after it
  1069.        receives a PDU from the remote endpoint that has a fastStart field. It
  1070.        is in response to a request for a fast strart from the local endpoint.
  1071.  
  1072.        If FALSE is returned the connection is aborted and a Release Complete
  1073.        PDU is sent.
  1074.  
  1075.        The default behaviour parses the provided array and starts the channels
  1076.        acknowledged in it.
  1077.      */
  1078.     virtual BOOL HandleFastStartAcknowledge(
  1079.       const H225_ArrayOf_PASN_OctetString & array   /// Array of H245_OpenLogicalChannel
  1080.     );
  1081.  
  1082.     /**Start a separate H245 channel.
  1083.        This function is called from one of a number of functions when it needs
  1084.        to create the h245 channel for the remote endpoint to connect back to.
  1085.  
  1086.        If FALSE is returned the connection is aborted and a Release Complete
  1087.        PDU is sent.
  1088.      */
  1089.     virtual BOOL StartControlChannel();
  1090.  
  1091.     /**Start a separate H245 channel.
  1092.        This function is called from one of a number of functions after it
  1093.        receives a PDU from the remote endpoint that has a h245Address field.
  1094.  
  1095.        If FALSE is returned the connection is aborted and a Release Complete
  1096.        PDU is sent.
  1097.  
  1098.        The default behaviour checks to see if it is a known transport and
  1099.        creates a corresponding H323Transport decendent for the control
  1100.        channel.
  1101.      */
  1102.     virtual BOOL StartControlChannel(
  1103.       const H225_TransportAddress & h245Address   /// H245 address
  1104.     );
  1105.   //@}
  1106.  
  1107.   /**@name Control Channel */
  1108.   //@{
  1109.     /**Write a PDU to the control channel.
  1110.        If there is no control channel open then this will tunnel the PDU
  1111.        into the signalling channel.
  1112.       */
  1113.     BOOL WriteControlPDU(
  1114.       const H323ControlPDU & pdu
  1115.     );
  1116.  
  1117.     /**Start control channel negotiations.
  1118.       */
  1119.     BOOL StartControlNegotiations();
  1120.  
  1121.     /**Handle reading data on the control channel.
  1122.      */
  1123.     virtual void HandleControlChannel();
  1124.  
  1125.     /**Handle incoming data on the control channel.
  1126.        This decodes the data stream into a PDU and calls HandleControlPDU().
  1127.  
  1128.        If FALSE is returned the connection is aborted. The default behaviour
  1129.        returns TRUE.
  1130.      */
  1131.     virtual BOOL HandleControlData(
  1132.       PPER_Stream & strm
  1133.     );
  1134.  
  1135.     /**Handle incoming PDU's on the control channel. Dispatches them to the
  1136.        various virtuals off this class.
  1137.  
  1138.        If FALSE is returned the connection is aborted. The default behaviour
  1139.        returns TRUE.
  1140.      */
  1141.     virtual BOOL HandleControlPDU(
  1142.       const H323ControlPDU & pdu
  1143.     );
  1144.  
  1145.     /**This function is called from the HandleControlPDU() function
  1146.        for unhandled PDU types.
  1147.  
  1148.        If FALSE is returned the connection is aborted and a Release Complete
  1149.        PDU is sent. The default behaviour returns TRUE.
  1150.  
  1151.        The default behaviour send a FunctioNotUnderstood indication back to
  1152.        the sender, and returns TRUE to continue operation.
  1153.      */
  1154.     virtual BOOL OnUnknownControlPDU(
  1155.       const H323ControlPDU & pdu  /// Received PDU
  1156.     );
  1157.  
  1158.     /**Handle incoming request PDU's on the control channel.
  1159.        Dispatches them to the various virtuals off this class.
  1160.      */
  1161.     virtual BOOL OnH245Request(
  1162.       const H323ControlPDU & pdu  /// Received PDU
  1163.     );
  1164.  
  1165.     /**Handle incoming response PDU's on the control channel.
  1166.        Dispatches them to the various virtuals off this class.
  1167.      */
  1168.     virtual BOOL OnH245Response(
  1169.       const H323ControlPDU & pdu  /// Received PDU
  1170.     );
  1171.  
  1172.     /**Handle incoming command PDU's on the control channel.
  1173.        Dispatches them to the various virtuals off this class.
  1174.      */
  1175.     virtual BOOL OnH245Command(
  1176.       const H323ControlPDU & pdu  /// Received PDU
  1177.     );
  1178.  
  1179.     /**Handle incoming indication PDU's on the control channel.
  1180.        Dispatches them to the various virtuals off this class.
  1181.      */
  1182.     virtual BOOL OnH245Indication(
  1183.       const H323ControlPDU & pdu  /// Received PDU
  1184.     );
  1185.  
  1186.     /**Handle H245 command to send terminal capability set.
  1187.      */
  1188.     virtual BOOL OnH245_SendTerminalCapabilitySet(
  1189.       const H245_SendTerminalCapabilitySet & pdu  /// Received PDU
  1190.     );
  1191.  
  1192.     /**Handle H245 command to control flow control.
  1193.        This function calls OnLogicalChannelFlowControl() with the channel and
  1194.        bit rate restriction.
  1195.      */
  1196.     virtual BOOL OnH245_FlowControlCommand(
  1197.       const H245_FlowControlCommand & pdu  /// Received PDU
  1198.     );
  1199.  
  1200.     /**Handle H245 miscellaneous command.
  1201.        This function passes the miscellaneous command on to the channel
  1202.        defined by the pdu.
  1203.      */
  1204.     virtual BOOL OnH245_MiscellaneousCommand(
  1205.       const H245_MiscellaneousCommand & pdu  /// Received PDU
  1206.     );
  1207.  
  1208.     /**Handle H245 miscellaneous indication.
  1209.        This function passes the miscellaneous indication on to the channel
  1210.        defined by the pdu.
  1211.      */
  1212.     virtual BOOL OnH245_MiscellaneousIndication(
  1213.       const H245_MiscellaneousIndication & pdu  /// Received PDU
  1214.     );
  1215.  
  1216.     /**Handle H245 indication of received jitter.
  1217.        This function calls OnLogicalChannelJitter() with the channel and
  1218.        estimated jitter.
  1219.      */
  1220.     virtual BOOL OnH245_JitterIndication(
  1221.       const H245_JitterIndication & pdu  /// Received PDU
  1222.     );
  1223.  
  1224.     /**Error discriminator for the OnControlProtocolError() function.
  1225.       */
  1226.     enum ControlProtocolErrors {
  1227.       e_MasterSlaveDetermination,
  1228.       e_CapabilityExchange,
  1229.       e_LogicalChannel,
  1230.       e_ModeRequest,
  1231.       e_RoundTripDelay
  1232.     };
  1233.  
  1234.     /**This function is called from the HandleControlPDU() function or
  1235.        any of its sub-functions for protocol errors, eg unhandled PDU types.
  1236.  
  1237.        The errorData field may be a string or PDU or some other data depending
  1238.        on the value of the errorSource parameter. These are:
  1239.           e_UnhandledPDU                    &H323ControlPDU
  1240.           e_MasterSlaveDetermination        const char *
  1241.  
  1242.        If FALSE is returned the connection is aborted. The default behaviour
  1243.        returns TRUE.
  1244.      */
  1245.     virtual BOOL OnControlProtocolError(
  1246.       ControlProtocolErrors errorSource,  // Source of the proptoerror
  1247.       const void * errorData = NULL       // Data associated with error
  1248.     );
  1249.  
  1250.     /**This function is called from the HandleControlPDU() function when
  1251.        it is about to send the Capabilities Set to the remote endpoint. This
  1252.        gives the application an oppurtunity to alter the PDU to be sent.
  1253.  
  1254.        The default behaviour will make "adjustments" for compatibility with
  1255.        some broken remote endpoints.
  1256.      */
  1257.     virtual void OnSendCapabilitySet(
  1258.       H245_TerminalCapabilitySet & pdu  /// PDU to send
  1259.     );
  1260.  
  1261.     /**This function is called when the remote endpoint sends its capability
  1262.        set. This gives the application an opportunity to determine what codecs
  1263.        are available and if it supports any of the combinations of codecs.
  1264.  
  1265.        Note any codec types that are the remote system supports that are not in
  1266.        the codecs list member variable for the endpoint are ignored and not
  1267.        included in the remoteCodecs list.
  1268.  
  1269.        The default behaviour assigns the table and set to member variables and
  1270.        returns TRUE if the remoteCodecs list is not empty.
  1271.      */
  1272.     virtual BOOL OnReceivedCapabilitySet(
  1273.       const H323Capabilities & remoteCaps,      /// Capability combinations remote supports
  1274.       const H245_MultiplexCapability * muxCap,  /// Transport capability, if present
  1275.       H245_TerminalCapabilitySetReject & reject /// Rejection PDU (if return FALSE)
  1276.     );
  1277.  
  1278.     /**Send a new capability set.
  1279.       */
  1280.     virtual void SendCapabilitySet(
  1281.       BOOL empty  /// Send an empty set.
  1282.     );
  1283.  
  1284.     /**Call back to set the local capabilities.
  1285.        This is called just before the capabilties are required when a call
  1286.        is begun. It is called when a SETUP PDU is received or when one is
  1287.        about to be sent, so that the capabilities may be adjusted for correct
  1288.        fast start operation.
  1289.  
  1290.        The default behaviour does nothing.
  1291.       */
  1292.     virtual void OnSetLocalCapabilities();
  1293.  
  1294.     /**Return if this H245 connection is a master or slave
  1295.      */
  1296.     BOOL IsH245Master() const;
  1297.  
  1298.     /**Start the round trip delay calculation over the control channel.
  1299.      */
  1300.     void StartRoundTripDelay();
  1301.  
  1302.     /**Get the round trip delay over the control channel.
  1303.      */
  1304.     PTimeInterval GetRoundTripDelay() const;
  1305.   //@}
  1306.  
  1307.   /**@name Logical Channel Management */
  1308.   //@{
  1309.     /**Call back to select logical channels to start.
  1310.  
  1311.        This function must be defined by the descendent class. It is used
  1312.        to select the logical channels to be opened between the two endpoints.
  1313.        There are three ways in which this may be called: when a "fast start"
  1314.        has been initiated by the local endpoint (via SendSignalSetup()
  1315.        function), when a "fast start" has been requested from the remote
  1316.        endpoint (via the OnReceivedSignalSetup() function) or when the H245
  1317.        capability set (and master/slave) negotiations have completed (via the
  1318.        OnControlChannelOpen() function.
  1319.  
  1320.        The function would typically examine several member variable to decide
  1321.        which mode it is being called in and what to do. If fastStartState is
  1322.        FastStartDisabled then non-fast start semantics should be used. The
  1323.        H245 capabilities in the remoteCapabilities members should be
  1324.        examined, and appropriate transmit channels started using
  1325.        OpenLogicalChannel().
  1326.  
  1327.        If fastStartState is FastStartInitiate, then the local endpoint has
  1328.        initiated a call and is asking the application if fast start semantics
  1329.        are to be used. If so it is expected that the function call 
  1330.        OpenLogicalChannel() for all the channels that it wishes to be able to
  1331.        be use. A subset (possibly none!) of these would actually be started
  1332.        when the remote endpoint replies.
  1333.  
  1334.        If fastStartState is FastStartResponse, then this indicates the remote
  1335.        endpoint is attempting a fast start. The fastStartChannels member
  1336.        contains a list of possible channels from the remote that the local
  1337.        endpoint is to select which to accept. For each accepted channel it
  1338.        simply necessary to call the Start() function on that channel eg
  1339.        fastStartChannels[0].Start();
  1340.  
  1341.        The default behaviour selects the first codec of each session number
  1342.        that is available. This is according to the order of the capabilities
  1343.        in the remoteCapabilities, the local capability table or of the
  1344.        fastStartChannels list respectively for each of the above scenarios.
  1345.       */
  1346.     virtual void OnSelectLogicalChannels();
  1347.  
  1348.     /**Select default logical channel for normal start.
  1349.       */
  1350.     virtual void SelectDefaultLogicalChannel(
  1351.       unsigned sessionID    /// Session ID to find default logical channel.
  1352.     );
  1353.  
  1354.     /**Select default logical channel for fast start.
  1355.        Internal function, not for normal use.
  1356.       */
  1357.     virtual void SelectFastStartChannels(
  1358.       unsigned sessionID,   /// Session ID to find default logical channel.
  1359.       BOOL transmitter,     /// Whether to open transmitters
  1360.       BOOL receiver         /// Whether to open receivers
  1361.     );
  1362.  
  1363.     /**Open a new logical channel.
  1364.        This function will open a channel between the endpoints for the
  1365.        specified capability.
  1366.  
  1367.        If this function is called while there is not yet a conenction
  1368.        established, eg from the OnFastStartLogicalChannels() function, then
  1369.        a "trial" receiver/transmitter channel is created. This channel is not
  1370.        started until the remote enpoint has confirmed that they are to start.
  1371.        Any channels not confirmed are deleted.
  1372.  
  1373.        If this function is called later in the call sequence, eg from
  1374.        OnSelectLogicalChannels(), then it may only establish a transmit
  1375.        channel, ie fromRemote must be FALSE.
  1376.       */
  1377.     virtual BOOL OpenLogicalChannel(
  1378.       const H323Capability & capability,  /// Capability to open channel with
  1379.       unsigned sessionID,                 /// Session for the channel
  1380.       H323Channel::Directions dir         /// Direction of channel
  1381.     );
  1382.  
  1383.     /**This function is called when the remote endpoint want's to open
  1384.        a new channel.
  1385.  
  1386.        If the return value is FALSE then the open is rejected using the
  1387.        errorCode as the cause, this would be a value from the enum
  1388.        H245_OpenLogicalChannelReject_cause::Choices.
  1389.  
  1390.        The default behaviour simply returns TRUE.
  1391.      */
  1392.     virtual BOOL OnOpenLogicalChannel(
  1393.       const H245_OpenLogicalChannel & openPDU,  /// Received PDU for the channel open
  1394.       H245_OpenLogicalChannelAck & ackPDU,      /// PDU to send for acknowledgement
  1395.       unsigned & errorCode                      /// Error to return if refused
  1396.     );
  1397.  
  1398.     /**Callback for when a logical channel conflict has occurred.
  1399.        This is called when the remote endpoint, which is a master, rejects
  1400.        our transmitter channel due to a resource conflict. Typically an
  1401.        inability to do asymmetric codecs. The local (slave) endpoint must then
  1402.        try and open a new transmitter channel using the same codec as the
  1403.        receiver that is being opened.
  1404.       */
  1405.     virtual BOOL OnConflictingLogicalChannel(
  1406.       H323Channel & channel    /// Channel that conflicted
  1407.     );
  1408.  
  1409.     /**Create a new logical channel object.
  1410.        This is in response to a request from the remote endpoint to open a
  1411.        logical channel.
  1412.       */
  1413.     virtual H323Channel * CreateLogicalChannel(
  1414.       const H245_OpenLogicalChannel & open, /// Parameters for opening channel
  1415.       BOOL startingFast,                    /// Flag for fast/slow starting.
  1416.       unsigned & errorCode                  /// Reason for create failure
  1417.     );
  1418.  
  1419.     /**Create a new real time logical channel object.
  1420.        This creates a logical channel for handling RTP data. It is primarily
  1421.        used to allow an application to redirect the RTP media streams to other
  1422.        hosts to the local one. In that case it would create an instance of
  1423.        the H323_ExternalRTPChannel class with the appropriate address. eg:
  1424.  
  1425.          H323Channel * MyConnection::CreateRealTimeLogicalChannel(
  1426.                                         const H323Capability & capability,
  1427.                                         H323Channel::Directions dir,
  1428.                                         unsigned sessionID,
  1429.                                         const H245_H2250LogicalChannelParameters * param)
  1430.          {
  1431.            return new H323_ExternalRTPChannel(*this, capability, dir, sessionID,
  1432.                                               externalIpAddress, externalPort);
  1433.          }
  1434.  
  1435.        An application would typically also override the OnStartLogicalChannel()
  1436.        function to obtain from the H323_ExternalRTPChannel instance the address
  1437.        of the remote endpoints media server RTP addresses to complete the
  1438.        setting up of the external RTP stack. eg:
  1439.  
  1440.          BOOL OnStartLogicalChannel(H323Channel & channel)
  1441.          {
  1442.            H323_ExternalRTPChannel & external = (H323_ExternalRTPChannel &)channel;
  1443.            external.GetRemoteAddress(remoteIpAddress, remotePort);
  1444.          }
  1445.  
  1446.        Note that the port in the above example is always the data port, the
  1447.        control port is assumed to be data+1.
  1448.  
  1449.        The default behaviour assures there is an RTP session for the session ID,
  1450.        and if not creates one, then creates a H323_RTPChannel which will do RTP
  1451.        media to the local host.
  1452.       */
  1453.     virtual H323Channel * CreateRealTimeLogicalChannel(
  1454.       const H323Capability & capability, /// Capability creating channel
  1455.       H323Channel::Directions dir,       /// Direction of channel
  1456.       unsigned sessionID,                /// Session ID for RTP channel
  1457.       const H245_H2250LogicalChannelParameters * param
  1458.                                          /// Parameters for channel
  1459.     );
  1460.  
  1461.     /**This function is called when the remote endpoint want's to create
  1462.        a new channel.
  1463.  
  1464.        If the return value is FALSE then the open is rejected using the
  1465.        errorCode as the cause, this would be a value from the enum
  1466.        H245_OpenLogicalChannelReject_cause::Choices.
  1467.  
  1468.        The default behaviour checks the capability set for if this capability
  1469.        is allowed to be opened with other channels that may already be open.
  1470.      */
  1471.     virtual BOOL OnCreateLogicalChannel(
  1472.       const H323Capability & capability,  /// Capability for the channel open
  1473.       H323Channel::Directions dir,        /// Direction of channel
  1474.       unsigned & errorCode                /// Error to return if refused
  1475.     );
  1476.  
  1477.     /**Call back function when a logical channel thread begins.
  1478.  
  1479.        The default behaviour does nothing and returns TRUE.
  1480.       */
  1481.     virtual BOOL OnStartLogicalChannel(
  1482.       H323Channel & channel    /// Channel that has been started.
  1483.     );
  1484.  
  1485.     /**Open a channel for use by an audio codec.
  1486.        The H323AudioCodec class will use this function to open the channel to
  1487.        read/write PCM data.
  1488.  
  1489.        The default behaviour calls the equivalent function on the endpoint.
  1490.       */
  1491.     virtual BOOL OpenAudioChannel(
  1492.       BOOL isEncoding,       /// Direction of data flow
  1493.       unsigned bufferSize,   /// Size of each sound buffer
  1494.       H323AudioCodec & codec /// codec that is doing the opening
  1495.     );
  1496.  
  1497. #ifndef NO_H323_VIDEO
  1498.     /**Open a channel for use by an video codec.
  1499.        The H323VideoCodec class will use this function to open the channel to
  1500.        read/write image data.
  1501.  
  1502.        The default behaviour calls the equivalent function on the endpoint.
  1503.       */
  1504.     virtual BOOL OpenVideoChannel(
  1505.       BOOL isEncoding,       /// Direction of data flow
  1506.       H323VideoCodec & codec /// codec doing the opening
  1507.     );
  1508. #endif // NO_H323_VIDEO
  1509.  
  1510.     /**Close a logical channel.
  1511.       */
  1512.     virtual void CloseLogicalChannel(
  1513.       unsigned number,    /// Channel number to close.
  1514.       BOOL fromRemote     /// Indicates close request of remote channel
  1515.     );
  1516.  
  1517.     /**Close a logical channel by number.
  1518.       */
  1519.     virtual void CloseLogicalChannelNumber(
  1520.       const H323ChannelNumber & number    /// Channel number to close.
  1521.     );
  1522.  
  1523.     /**Close a logical channel.
  1524.       */
  1525.     virtual void CloseAllLogicalChannels(
  1526.       BOOL fromRemote     /// Indicates close request of remote channel
  1527.     );
  1528.  
  1529.     /**This function is called when the remote endpoint has closed down
  1530.        a logical channel.
  1531.  
  1532.        The default behaviour does nothing.
  1533.      */
  1534.     virtual void OnClosedLogicalChannel(
  1535.       const H323Channel & channel   /// Channel that was closed
  1536.     );
  1537.  
  1538.     /**This function is called when the remote endpoint request the close of
  1539.        a logical channel.
  1540.  
  1541.        The application may get an opportunity to refuse to close the channel by
  1542.        returning FALSE from this function.
  1543.  
  1544.        The default behaviour returns TRUE.
  1545.      */
  1546.     virtual BOOL OnClosingLogicalChannel(
  1547.       H323Channel & channel   /// Channel that is to be closed
  1548.     );
  1549.  
  1550.     /**This function is called when the remote endpoint wishes to limit the
  1551.        bit rate being sent on a channel.
  1552.  
  1553.        If channel is NULL, then the bit rate limit applies to all channels.
  1554.  
  1555.        The default behaviour does nothing if channel is NULL, otherwise calls
  1556.        H323Channel::OnFlowControl() on the specific channel.
  1557.      */
  1558.     virtual void OnLogicalChannelFlowControl(
  1559.       H323Channel * channel,   /// Channel that is to be limited
  1560.       long bitRateRestriction  /// Limit for channel
  1561.     );
  1562.  
  1563.     /**This function is called when the remote endpoint indicates the level
  1564.        of jitter estimated by the receiver.
  1565.  
  1566.        If channel is NULL, then the jitter applies to all channels.
  1567.  
  1568.        The default behaviour does nothing if channel is NULL, otherwise calls
  1569.        H323Channel::OnJitter() on the specific channel.
  1570.      */
  1571.     virtual void OnLogicalChannelJitter(
  1572.       H323Channel * channel,   /// Channel that is to be limited
  1573.       DWORD jitter,            /// Estimated received jitter in microseconds
  1574.       int skippedFrameCount,   /// Frames skipped by decodec
  1575.       int additionalBuffer     /// Additional size of video decoder buffer
  1576.     );
  1577.  
  1578.     /**Send a miscellaneous command on the associated H245 channel.
  1579.     */
  1580.     void SendLogicalChannelMiscCommand(
  1581.       H323Channel & channel,  /// Channel to send command for
  1582.       unsigned command        /// Command code to send
  1583.     );
  1584.  
  1585.     /**Get a logical channel.
  1586.        Locates the specified channel number and returns a pointer to it.
  1587.       */
  1588.     H323Channel * GetLogicalChannel(
  1589.       unsigned number,    /// Channel number to get.
  1590.       BOOL fromRemote     /// Indicates get a remote channel
  1591.     ) const;
  1592.  
  1593.     /**Find a logical channel.
  1594.        Locates a channel give a RTP session ID. Each session would usually
  1595.        have two logical channels associated with it, so the fromRemote flag
  1596.        bay be used to distinguish which channel to return.
  1597.       */
  1598.     H323Channel * FindChannel(
  1599.       unsigned sessionId,   /// Session ID to search for.
  1600.       BOOL fromRemote       /// Indicates the direction of RTP data.
  1601.     ) const;
  1602.   //@}
  1603.  
  1604.   /**@name Bandwidth Management */
  1605.   //@{
  1606.     /**Get the bandwidth currently used.
  1607.        This totals the open channels and returns the total bandwidth used in
  1608.        100's of bits/sec
  1609.       */
  1610.     unsigned GetBandwidthUsed() const;
  1611.  
  1612.     /**Request use the available bandwidth in 100's of bits/sec.
  1613.        If there is insufficient bandwidth available, FALSE is returned. If
  1614.        sufficient bandwidth is available, then TRUE is returned and the amount
  1615.        of available bandwidth is reduced by the specified amount.
  1616.       */
  1617.     BOOL UseBandwidth(
  1618.       unsigned bandwidth,     /// Bandwidth required
  1619.       BOOL removing           /// Flag for adding/removing bandwidth usage
  1620.     );
  1621.  
  1622.     /**Get the available bandwidth in 100's of bits/sec.
  1623.       */
  1624.     unsigned GetBandwidthAvailable() const { return bandwidthAvailable; }
  1625.  
  1626.     /**Set the available bandwidth in 100's of bits/sec.
  1627.        Note if the force parameter is TRUE this function will close down
  1628.        active logical channels to meet the new bandwidth requirement.
  1629.       */
  1630.     BOOL SetBandwidthAvailable(
  1631.       unsigned newBandwidth,    /// New bandwidth limit
  1632.       BOOL force = FALSE        /// Force bandwidth limit
  1633.     );
  1634.   //@}
  1635.  
  1636.   /**@name Indications */
  1637.   //@{
  1638.     enum SendUserInputModes {
  1639.       SendUserInputAsQ931,
  1640.       SendUserInputAsString,
  1641.       SendUserInputAsTone,
  1642.       SendUserInputAsInlineRFC2833,
  1643.       SendUserInputAsSeparateRFC2833,  // Not implemented
  1644.       NumSendUserInputModes
  1645.     };
  1646. #if PTRACING
  1647.     friend ostream & operator<<(ostream & o, SendUserInputModes m);
  1648. #endif
  1649.  
  1650.     /**Set the user input indication transmission mode.
  1651.       */
  1652.     void SetSendUserInputMode(SendUserInputModes mode);
  1653.  
  1654.     /**Get the user input indication transmission mode.
  1655.       */
  1656.     SendUserInputModes GetSendUserInputMode() const { return sendUserInputMode; }
  1657.  
  1658.     /**Get the real user input indication transmission mode.
  1659.        This will return the user input mode that will actually be used for
  1660.        transmissions. It will be the value of GetSendUserInputMode() provided
  1661.        the remote endpoint is capable of that mode.
  1662.       */
  1663.     SendUserInputModes GetRealSendUserInputMode() const;
  1664.  
  1665.     /**Send a user input indication to the remote endpoint.
  1666.        This is for sending arbitrary strings as user indications.
  1667.  
  1668.        The user indication is sent according to the sendUserInputMode member
  1669.        variable. If SendUserInputAsString then this uses an H.245 "string"
  1670.        UserInputIndication pdu sending the entire string in one go. If
  1671.        SendUserInputAsTone then a separate H.245 "signal" UserInputIndication
  1672.        pdu is sent for each character. If SendUserInputAsInlineRFC2833 then
  1673.        the indication is inserted into the outgoing audio stream as an RFC2833
  1674.        RTP data pdu.
  1675.  
  1676.        SendUserInputAsSeparateRFC2833 is not yet supported.
  1677.       */
  1678.     virtual void SendUserInput(
  1679.       const PString & value                   /// String value of indication
  1680.     );
  1681.  
  1682.     /**Call back for remote endpoint has sent user input.
  1683.        This will be called irrespective of the source (H.245 string, H.245
  1684.        signal or RFC2833).
  1685.  
  1686.        The default behaviour calls the endpoint function of the same name.
  1687.       */
  1688.     virtual void OnUserInputString(
  1689.       const PString & value   /// String value of indication
  1690.     );
  1691.  
  1692.     /**Send a user input indication to the remote endpoint.
  1693.        This sends DTMF emulation user input. If something more sophisticated
  1694.        than the simple tones that can be sent using the SendUserInput()
  1695.        function.
  1696.  
  1697.        A duration of zero indicates that no duration is to be indicated.
  1698.        A non-zero logical channel indicates that the tone is to be syncronised
  1699.        with the logical channel at the rtpTimestamp value specified.
  1700.  
  1701.        The tone parameter must be one of "0123456789#*ABCD!" where '!'
  1702.        indicates a hook flash. If tone is a ' ' character then a
  1703.        signalUpdate PDU is sent that updates the last tone indication
  1704.        sent. See the H.245 specifcation for more details on this.
  1705.  
  1706.        The user indication is sent according to the sendUserInputMode member
  1707.        variable. If SendUserInputAsString then this uses an H.245 "string"
  1708.        UserInputIndication pdu sending the entire string in one go. If
  1709.        SendUserInputAsTone then a separate H.245 "signal" UserInputIndication
  1710.        pdu is sent for each character. If SendUserInputAsInlineRFC2833 then
  1711.        the indication is inserted into the outgoing audio stream as an RFC2833
  1712.        RTP data pdu.
  1713.  
  1714.        SendUserInputAsSeparateRFC2833 is not yet supported.
  1715.       */
  1716.     virtual void SendUserInputTone(
  1717.       char tone,                   /// DTMF tone code
  1718.       unsigned duration = 0,       /// Duration of tone in milliseconds
  1719.       unsigned logicalChannel = 0, /// Logical channel number for RTP sync.
  1720.       unsigned rtpTimestamp = 0    /// RTP timestamp in logical channel sync.
  1721.     );
  1722.  
  1723.     /**Call back for remote enpoint has sent user input.
  1724.  
  1725.        The default behaviour calls the endpoint function of the same name.
  1726.       */
  1727.     virtual void OnUserInputTone(
  1728.       char tone,               /// DTMF tone code
  1729.       unsigned duration,       /// Duration of tone in milliseconds
  1730.       unsigned logicalChannel, /// Logical channel number for RTP sync.
  1731.       unsigned rtpTimestamp    /// RTP timestamp in logical channel sync.
  1732.     );
  1733.  
  1734.     /**Send a user input indication to the remote endpoint.
  1735.        This sends a Hook Flash emulation user input.
  1736.       */
  1737.     void SendUserInputHookFlash(
  1738.       int duration = 500  /// Duration of tone in milliseconds
  1739.     ) { SendUserInputTone('!', duration); }
  1740.  
  1741.     /**Send a user input indication to the remote endpoint.
  1742.        This is for sending arbitrary strings as user indications.
  1743.  
  1744.        This always uses a Q.931 Keypad Information Element in a Information
  1745.        pdu sending the entire string in one go.
  1746.       */
  1747.     virtual void SendUserInputIndicationQ931(
  1748.       const PString & value                   /// String value of indication
  1749.     );
  1750.  
  1751.     /**Send a user input indication to the remote endpoint.
  1752.        This is for sending arbitrary strings as user indications.
  1753.  
  1754.        This always uses an H.245 "string" UserInputIndication pdu sending the
  1755.        entire string in one go.
  1756.       */
  1757.     virtual void SendUserInputIndicationString(
  1758.       const PString & value                   /// String value of indication
  1759.     );
  1760.  
  1761.     /**Send a user input indication to the remote endpoint.
  1762.        This sends DTMF emulation user input.This uses an H.245 "signal"
  1763.        UserInputIndication pdu.
  1764.       */
  1765.     virtual void SendUserInputIndicationTone(
  1766.       char tone,                   /// DTMF tone code
  1767.       unsigned duration = 0,       /// Duration of tone in milliseconds
  1768.       unsigned logicalChannel = 0, /// Logical channel number for RTP sync.
  1769.       unsigned rtpTimestamp = 0    /// RTP timestamp in logical channel sync.
  1770.     );
  1771.  
  1772.     /**Send a user input indication to the remote endpoint.
  1773.        The two forms are for basic user input of a simple string using the
  1774.        SendUserInput() function or a full DTMF emulation user input using the
  1775.        SendUserInputTone() function.
  1776.  
  1777.        An application could do more sophisticated usage by filling in the 
  1778.        H245_UserInputIndication structure directly ans using this function.
  1779.       */
  1780.     virtual void SendUserInputIndication(
  1781.       const H245_UserInputIndication & pdu    /// Full user indication PDU
  1782.     );
  1783.  
  1784.     /**Call back for remote enpoint has sent user input.
  1785.        The default behaviour calls OnUserInputString() if the PDU is of the
  1786.        alphanumeric type, or OnUserInputTone() if of a tone type.
  1787.       */
  1788.     virtual void OnUserInputIndication(
  1789.       const H245_UserInputIndication & pdu  /// Full user indication PDU
  1790.     );
  1791.   //@}
  1792.  
  1793.   /**@name RTP Session Management */
  1794.   //@{
  1795.     /**Get an RTP session for the specified ID.
  1796.        If there is no session of the specified ID, NULL is returned.
  1797.       */
  1798.     virtual RTP_Session * GetSession(
  1799.       unsigned sessionID
  1800.     ) const;
  1801.  
  1802.     /**Get an H323 RTP session for the specified ID.
  1803.        If there is no session of the specified ID, NULL is returned.
  1804.       */
  1805.     virtual H323_RTP_Session * GetSessionCallbacks(
  1806.       unsigned sessionID
  1807.     ) const;
  1808.  
  1809.     /**Use an RTP session for the specified ID.
  1810.        If there is no session of the specified ID, a new one is created using
  1811.        the information prvided in the H245_TransportAddress PDU. If the system
  1812.        does not support the specified transport, NULL is returned.
  1813.  
  1814.        If this function is used, then the ReleaseSession() function MUST be
  1815.        called or the session is never deleted for the lifetime of the H323
  1816.        connection.
  1817.       */
  1818.     virtual RTP_Session * UseSession(
  1819.       unsigned sessionID,
  1820.       const H245_TransportAddress & pdu
  1821.     );
  1822.  
  1823.     /**Release the session. If the session ID is not being used any more any
  1824.        clients via the UseSession() function, then the session is deleted.
  1825.      */
  1826.     virtual void ReleaseSession(
  1827.       unsigned sessionID
  1828.     );
  1829.  
  1830.     /**Callback from the RTP session for statistics monitoring.
  1831.        This is called every so many packets on the transmitter and receiver
  1832.        threads of the RTP session indicating that the statistics have been
  1833.        updated.
  1834.  
  1835.        The default behaviour calls H323EndPoint::OnRTPStatistics().
  1836.       */
  1837.     virtual void OnRTPStatistics(
  1838.       const RTP_Session & session   /// Session with statistics
  1839.     ) const;
  1840.  
  1841.     /**Get the names of the codecs in use for the RTP session.
  1842.        If there is no session of the specified ID, an empty string is returned.
  1843.       */
  1844.     virtual PString GetSessionCodecNames(
  1845.       unsigned sessionID
  1846.     ) const;
  1847.   //@}
  1848.  
  1849.   /**@name Request Mode Changes */
  1850.   //@{
  1851.     /**Make a request to mode change to remote.
  1852.        This asks the remote system to stop it transmitters and start sending
  1853.        one of the combinations specifed.
  1854.  
  1855.        The modes are separated in the string by \n characters, and all of the
  1856.        channels (capabilities) are strings separated by \t characters. Thus a
  1857.        very simple mode change would be "T.38" which requests that the remote
  1858.        start sending T.38 data and nothing else. A more complicated example
  1859.        would be "G.723\tH.261\nG.729\tH.261\nG.728" which indicates that the
  1860.        remote should either start sending G.723 and H.261, G.729 and H.261 or
  1861.        just G.728 on its own.
  1862.  
  1863.        Returns FALSE if a mode change is currently in progress, only one mode
  1864.        change may be done at a time.
  1865.       */
  1866.     virtual BOOL RequestModeChange(
  1867.       const PString & newModes  /// New modes to select
  1868.     );
  1869.  
  1870.     /**Make a request to mode change to remote.
  1871.        This asks the remote system to stop it transmitters and start sending
  1872.        one of the combinations specifed.
  1873.  
  1874.        Returns FALSE if a mode change is currently in progress, only one mode
  1875.        change may be done at a time.
  1876.       */
  1877.     virtual BOOL RequestModeChange(
  1878.       const H245_ArrayOf_ModeDescription & newModes  /// New modes to select
  1879.     );
  1880.  
  1881.     /**Received request for mode change from remote.
  1882.       */
  1883.     virtual BOOL OnRequestModeChange(
  1884.       const H245_RequestMode & pdu,     /// Received PDU
  1885.       H245_RequestModeAck & ack,        /// Ack PDU to send
  1886.       H245_RequestModeReject & reject,  /// Reject PDU to send
  1887.       PINDEX & selectedMode           /// Which mode was selected
  1888.     );
  1889.  
  1890.     /**Completed request for mode change from remote.
  1891.        This is a call back that accurs after the ack has been sent to the
  1892.        remote as indicated by the OnRequestModeChange() return result. This
  1893.        function is intended to actually implement the mode change after it
  1894.        had been accepted.
  1895.       */
  1896.     virtual void OnModeChanged(
  1897.       const H245_ModeDescription & newMode
  1898.     );
  1899.  
  1900.     /**Received acceptance of last mode change request.
  1901.        This callback indicates that the RequestModeChange() was accepted by
  1902.        the remote endpoint.
  1903.       */
  1904.     virtual void OnAcceptModeChange(
  1905.       const H245_RequestModeAck & pdu  /// Received PDU
  1906.     );
  1907.  
  1908.     /**Received reject of last mode change request.
  1909.        This callback indicates that the RequestModeChange() was accepted by
  1910.        the remote endpoint.
  1911.       */
  1912.     virtual void OnRefusedModeChange(
  1913.       const H245_RequestModeReject * pdu  /// Received PDU, if NULL is a timeout
  1914.     );
  1915.   //@}
  1916.  
  1917.   /**@name Other services */
  1918.   //@{
  1919.     /**Create an instance of the T.120 protocol handler.
  1920.        This is called when the OpenLogicalChannel subsystem requires that
  1921.        a T.120 channel be established.
  1922.  
  1923.        Note that if the application overrides this and returns a pointer to a
  1924.        heap variable (using new) then it is the responsibility of the creator
  1925.        to subsequently delete the object. The user of this function (the 
  1926.        H323_T120Channel class) will not do so.
  1927.  
  1928.        The default behavour returns H323Endpoint::CreateT120ProtocolHandler()
  1929.        while keeping track of that variable for autmatic deletion.
  1930.       */
  1931.     virtual OpalT120Protocol * CreateT120ProtocolHandler();
  1932.  
  1933.     /**Create an instance of the T.38 protocol handler.
  1934.        This is called when the OpenLogicalChannel subsystem requires that
  1935.        a T.38 fax channel be established.
  1936.  
  1937.        Note that if the application overrides this and returns a pointer to a
  1938.        heap variable (using new) then it is the responsibility of the creator
  1939.        to subsequently delete the object. The user of this function (the 
  1940.        H323_T38Channel class) will not do so.
  1941.  
  1942.        The default behavour returns H323Endpoint::CreateT38ProtocolHandler()
  1943.        while keeping track of that variable for autmatic deletion.
  1944.       */
  1945.     virtual OpalT38Protocol * CreateT38ProtocolHandler();
  1946.  
  1947.     /**Request a mode change to T.38 data.
  1948.       */
  1949.     virtual BOOL RequestModeChangeT38(
  1950.       const char * capabilityNames = "T.38\nT38FaxUDP"
  1951.     );
  1952.  
  1953.     /**Get separate H.235 authentication for the connection.
  1954.        This allows an individual ARQ to override the authentical credentials
  1955.        used in H.235 based RAS for this particular connection.
  1956.  
  1957.        A return value of FALSE indicates to use the default credentials of the
  1958.        endpoint, while TRUE indicates that new credentials are to be used.
  1959.  
  1960.        The default behavour does nothing and returns FALSE.
  1961.       */
  1962.     virtual BOOL GetAdmissionRequestAuthentication(
  1963.       const H225_AdmissionRequest & arq,  /// ARQ being constructed
  1964.       H235Authenticators & authenticators /// New authenticators for ARQ
  1965.     );
  1966.   //@}
  1967.  
  1968.   /**@name Member variable access */
  1969.   //@{
  1970.     /**Get the owner endpoint for this connection.
  1971.      */
  1972.     H323EndPoint & GetEndPoint() const { return endpoint; }
  1973.  
  1974.     /**Get the call direction for this connection.
  1975.      */
  1976.     BOOL HadAnsweredCall() const { return callAnswered; }
  1977.  
  1978.     /**Determined if connection is gatekeeper routed.
  1979.      */
  1980.     BOOL IsGatekeeperRouted() const { return gatekeeperRouted; }
  1981.  
  1982.     /**Get the Q.931 cause code (Q.850) that terminated this call.
  1983.        See Q931::CauseValues for common values.
  1984.      */
  1985.     unsigned GetQ931Cause() const { return q931Cause; }
  1986.  
  1987.     /**Get the distinctive ring code for incoming call.
  1988.        This returns an integer from 0 to 7 that may indicate to an application
  1989.        that different ring cadences are to be used.
  1990.       */
  1991.     unsigned GetDistinctiveRing() const { return distinctiveRing; }
  1992.  
  1993.     /**Set the distinctive ring code for outgoing call.
  1994.        This sets the integer from 0 to 7 that will be used in the outgoing
  1995.        Setup PDU. Note this must be called either immediately after
  1996.        construction or during the OnSendSignalSetup() callback function so the
  1997.        member variable is set befor ethe PDU is sent.
  1998.       */
  1999.     void SetDistinctiveRing(unsigned pattern) { distinctiveRing = pattern&7; }
  2000.  
  2001.     /**Get the internal OpenH323 call token for this connection.
  2002.      */
  2003.     const PString & GetCallToken() const { return callToken; }
  2004.  
  2005.     /**Get the call reference for this connection.
  2006.      */
  2007.     unsigned GetCallReference() const { return callReference; }
  2008.  
  2009.     /**Get the call identifier for this connection.
  2010.      */
  2011.     const OpalGloballyUniqueID & GetCallIdentifier() const { return callIdentifier; }
  2012.  
  2013.     /**Get the conference identifier for this connection.
  2014.      */
  2015.     const OpalGloballyUniqueID & GetConferenceIdentifier() const { return conferenceIdentifier; }
  2016.  
  2017.     /**Get the local name/alias.
  2018.       */
  2019.     const PString & GetLocalPartyName() const { return localPartyName; }
  2020.  
  2021.     /**Set the local name/alias from information in the PDU.
  2022.       */
  2023.     void SetLocalPartyName(const PString & name);
  2024.  
  2025.     const PStringList & GetLocalAliasNames() const { return localAliasNames; }
  2026.  
  2027.     /**Get the remote party name.
  2028.        This returns a string indicating the remote parties names and aliases.
  2029.        This can be a complicated string containing all the aliases and the
  2030.        remote host name. For example:
  2031.               "Fred Nurk (fred, 5551234) [fred.nurk.com]"
  2032.       */
  2033.     const PString & GetRemotePartyName() const { return remotePartyName; }
  2034.  
  2035.     /**Get the remote party number, if there was one one.
  2036.        If the remote party has indicated an e164 number as one of its aliases
  2037.        or as a field in the Q.931 PDU, then this function will return it.
  2038.       */
  2039.     const PString & GetRemotePartyNumber() const { return remotePartyNumber; }
  2040.  
  2041.     /**Get the remote party address.
  2042.        This will return the "best guess" at an address to use in a
  2043.        H323EndPoint::MakeCall() function to call the remote party back again.
  2044.        Note that due to the presence of gatekeepers/proxies etc this may not
  2045.        always be accurate.
  2046.       */
  2047.     const PString & GetRemotePartyAddress() const { return remotePartyAddress; }
  2048.  
  2049.     /**Set the name/alias of remote end from information in the PDU.
  2050.       */
  2051.     void SetRemotePartyInfo(
  2052.       const H323SignalPDU & pdu /// PDU from which to extract party info.
  2053.     );
  2054.  
  2055.     /**Get the remote application name and version.
  2056.        This information is obtained from the sourceInfo field of the H.225
  2057.        Setup PDU or the destinationInfo of the call proceeding or alerting
  2058.        PDU's. The general format of the string will be information extracted
  2059.        from the VendorIdentifier field of the EndpointType. In particular:
  2060.  
  2061.           productId <tab> versionId <tab> t35CountryCode/manufacturerCode
  2062.  
  2063.        for example
  2064.           "Equivalence OpenPhone\t1.4.2\t9/61"
  2065.       */
  2066.     const PString & GetRemoteApplication() const { return remoteApplication; }
  2067.  
  2068.     /**Set the name/alias of remote end from information in the PDU.
  2069.       */
  2070.     void SetRemoteApplication(
  2071.       const H225_EndpointType & pdu /// PDU from which to extract application info.
  2072.     );
  2073.     
  2074.     /**Get the remotes capability table for this connection.
  2075.      */
  2076.     const H323Capabilities & GetLocalCapabilities() const { return localCapabilities; }
  2077.  
  2078.     /**Get the remotes capability table for this connection.
  2079.      */
  2080.     const H323Capabilities & GetRemoteCapabilities() const { return remoteCapabilities; }
  2081.  
  2082.     /**Get the maximum audio jitter delay.
  2083.      */
  2084.     unsigned GetRemoteMaxAudioDelayJitter() const { return remoteMaxAudioDelayJitter; }
  2085.  
  2086.     /**Get the signalling channel being used.
  2087.       */
  2088.     const H323Transport * GetSignallingChannel() const { return signallingChannel; }
  2089.  
  2090.     /**Get the signalling channel protocol version number.
  2091.       */
  2092.     unsigned GetSignallingVersion() const { return h225version; }
  2093.  
  2094.     /**Get the control channel being used (may return signalling channel).
  2095.       */
  2096.     const H323Transport & GetControlChannel() const;
  2097.  
  2098.     /**Get the control channel protocol version number.
  2099.       */
  2100.     unsigned GetControlVersion() const { return h245version; }
  2101.  
  2102.     /**Get the time at which the connection was begun
  2103.       */
  2104.     PTime GetSetupUpTime() const { return setupTime; }
  2105.  
  2106.     /**Get the time at which the ALERTING was received
  2107.       */
  2108.     PTime GetAlertingTime() const { return alertingTime; }
  2109.  
  2110.     /**Get the time at which the connection was connected. That is the point
  2111.        at which charging is likely to have begun.
  2112.       */
  2113.     PTime GetConnectionStartTime() const { return connectedTime; }
  2114.  
  2115.     /**Get the time at which the connection was cleared
  2116.       */
  2117.     PTime GetConnectionEndTime() const { return callEndTime; }
  2118.  
  2119.     /**Get the default maximum audio jitter delay parameter.
  2120.        Defaults to 50ms
  2121.      */
  2122.     unsigned GetMinAudioJitterDelay() const { return minAudioJitterDelay; }
  2123.  
  2124.     /**Get the default maximum audio delay jitter parameter.
  2125.        Defaults to 250ms.
  2126.      */
  2127.     unsigned GetMaxAudioJitterDelay() const { return maxAudioJitterDelay; }
  2128.  
  2129.     /**Set the maximum audio delay jitter parameter.
  2130.      */
  2131.     void SetAudioJitterDelay(
  2132.       unsigned minDelay,   // New minimum jitter buffer delay in milliseconds
  2133.       unsigned maxDelay    // New maximum jitter buffer delay in milliseconds
  2134.     );
  2135.  
  2136.     /**Get the UUIE PDU monitor bit mask.
  2137.      */
  2138.     unsigned GetUUIEsRequested() const { return uuiesRequested; }
  2139.  
  2140.     /**Set the UUIE PDU monitor bit mask.
  2141.      */
  2142.     void SetUUIEsRequested(unsigned mask) { uuiesRequested = mask; }
  2143.  
  2144.     /**Get the iNow Gatekeeper Access Token OID.
  2145.      */
  2146.     const PString GetGkAccessTokenOID() const { return gkAccessTokenOID; }
  2147.  
  2148.     /**Set the iNow Gatekeeper Access Token OID.
  2149.      */
  2150.     void SetGkAccessTokenOID(const PString & oid) { gkAccessTokenOID = oid; }
  2151.  
  2152.     /**Get the iNow Gatekeeper Access Token data.
  2153.      */
  2154.     const PBYTEArray & GetGkAccessTokenData() const { return gkAccessTokenData; }
  2155.  
  2156.     /**Set the Destionation Extra Call Info memeber.
  2157.      */
  2158.     void SetDestExtraCallInfo(
  2159.       const PString & info
  2160.     ) { destExtraCallInfo = info; }
  2161.  
  2162.     /** Set the remote call waiting flag
  2163.      */
  2164.     void SetRemotCallWaiting(const unsigned value) { remoteCallWaiting = value; }
  2165.  
  2166.     /**How many caller's are waiting on the remote endpoint?
  2167.       -1 - None
  2168.        0 - Just this connection
  2169.        n - n plus this connection
  2170.      */
  2171.     const int GetRemoteCallWaiting() const { return remoteCallWaiting; }
  2172.  
  2173.     /**Set the enforced duration limit for the call.
  2174.        This starts a timer that will automatically shut down the call when it
  2175.        expires.
  2176.       */
  2177.     void SetEnforcedDurationLimit(
  2178.       unsigned seconds  /// max duration of call in seconds
  2179.     );
  2180.   //@}
  2181.  
  2182.  
  2183.   protected:
  2184.     /**Internal function to check if call established.
  2185.        This checks all the criteria for establishing a call an initiating the
  2186.        starting of media channels, if they have not already been started via
  2187.        the fast start algorithm.
  2188.     */
  2189.     virtual void InternalEstablishedConnectionCheck();
  2190.     BOOL InternalEndSessionCheck(PPER_Stream & strm);
  2191.     void SetRemoteVersions(const H225_ProtocolIdentifier & id);
  2192.     void MonitorCallStatus();
  2193.     PDECLARE_NOTIFIER(OpalRFC2833Info, H323Connection, OnUserInputInlineRFC2833);
  2194.     PDECLARE_NOTIFIER(H323Codec::FilterInfo, H323Connection, OnUserInputInBandDTMF);
  2195.  
  2196.     H323EndPoint & endpoint;
  2197.     PSyncPoint     * endSync;
  2198.  
  2199.     int                  remoteCallWaiting; // Number of call's waiting at the remote endpoint
  2200.     BOOL                 callAnswered;
  2201.     BOOL                 gatekeeperRouted;
  2202.     unsigned             distinctiveRing;
  2203.     PString              callToken;
  2204.     unsigned             callReference;
  2205.     OpalGloballyUniqueID callIdentifier;
  2206.     OpalGloballyUniqueID conferenceIdentifier;
  2207.  
  2208.     PStringList        localAliasNames;
  2209.     PString            localPartyName;
  2210.     H323Capabilities   localCapabilities; // Capabilities local system supports
  2211.     PString            remotePartyName;
  2212.     PString            remotePartyNumber;
  2213.     PString            remotePartyAddress;
  2214.     PString            destExtraCallInfo;
  2215.     PString            remoteApplication;
  2216.     H323Capabilities   remoteCapabilities; // Capabilities remote system supports
  2217.     unsigned           remoteMaxAudioDelayJitter;
  2218.     PTimer             roundTripDelayTimer;
  2219.     unsigned           minAudioJitterDelay;
  2220.     unsigned           maxAudioJitterDelay;
  2221.     unsigned           bandwidthAvailable;
  2222.     unsigned           uuiesRequested;
  2223.     PString            gkAccessTokenOID;
  2224.     PBYTEArray         gkAccessTokenData;
  2225.     BOOL               addAccessTokenToSetup;
  2226.     SendUserInputModes sendUserInputMode;
  2227.  
  2228.     H323Transport * signallingChannel;
  2229.     H323Transport * controlChannel;
  2230.     BOOL            h245Tunneling;
  2231.     H323SignalPDU * h245TunnelRxPDU;
  2232.     H323SignalPDU * h245TunnelTxPDU;
  2233.     H323SignalPDU * alertingPDU;
  2234.     H323SignalPDU * connectPDU;
  2235.  
  2236.     enum ConnectionStates {
  2237.       NoConnectionActive,
  2238.       AwaitingGatekeeperAdmission,
  2239.       AwaitingTransportConnect,
  2240.       AwaitingSignalConnect,
  2241.       AwaitingLocalAnswer,
  2242.       HasExecutedSignalConnect,
  2243.       EstablishedConnection,
  2244.       ShuttingDownConnection,
  2245.       NumConnectionStates
  2246.     } connectionState;
  2247.  
  2248.     PTime         setupTime;
  2249.     PTime         alertingTime;
  2250.     PTime         connectedTime;
  2251.     PTime         callEndTime;
  2252.     CallEndReason callEndReason;
  2253.     unsigned      q931Cause;
  2254.  
  2255.     unsigned   h225version;
  2256.     unsigned   h245version;
  2257.     BOOL       h245versionSet;
  2258.     BOOL doH245inSETUP;
  2259.     BOOL lastPDUWasH245inSETUP;
  2260.     BOOL detectInBandDTMF;
  2261.     BOOL mustSendDRQ;
  2262.     BOOL mediaWaitForConnect;
  2263.     BOOL transmitterSidePaused;
  2264.     BOOL earlyStart;
  2265.     BOOL startT120;
  2266.     PString    t38ModeChangeCapabilities;
  2267.     PSyncPoint digitsWaitFlag;
  2268.     BOOL       endSessionNeeded;
  2269.     BOOL       endSessionSent;
  2270.     PSyncPoint endSessionReceived;
  2271.     PTimer     enforcedDurationLimit;
  2272.  
  2273.     // Used as part of a local call hold operation involving MOH
  2274.     PChannel * holdMediaChannel;
  2275.     BOOL       isConsultationTransfer;
  2276.  
  2277.     /** Call Intrusion flag and parameters */
  2278.     BOOL     isCallIntrusion;
  2279.     unsigned callIntrusionProtectionLevel;
  2280.  
  2281.     RTP_SessionManager rtpSessions;
  2282.  
  2283.     enum FastStartStates {
  2284.       FastStartDisabled,
  2285.       FastStartInitiate,
  2286.       FastStartResponse,
  2287.       FastStartAcknowledged,
  2288.       NumFastStartStates
  2289.     };
  2290.     FastStartStates        fastStartState;
  2291.     H323LogicalChannelList fastStartChannels;
  2292.  
  2293. #if PTRACING
  2294.     static const char * const ConnectionStatesNames[NumConnectionStates];
  2295.     friend ostream & operator<<(ostream & o, ConnectionStates s) { return o << ConnectionStatesNames[s]; }
  2296.     static const char * const FastStartStateNames[NumFastStartStates];
  2297.     friend ostream & operator<<(ostream & o, FastStartStates s) { return o << FastStartStateNames[s]; }
  2298. #endif
  2299.  
  2300.  
  2301.     // The following pointers are to protocol procedures, they are pointers to
  2302.     // hide their complexity from the H323Connection classes users.
  2303.     H245NegMasterSlaveDetermination  * masterSlaveDeterminationProcedure;
  2304.     H245NegTerminalCapabilitySet     * capabilityExchangeProcedure;
  2305.     H245NegLogicalChannels           * logicalChannels;
  2306.     H245NegRequestMode               * requestModeProcedure;
  2307.     H245NegRoundTripDelay            * roundTripDelayProcedure;
  2308.     H450xDispatcher                  * h450dispatcher;
  2309.     H4502Handler                     * h4502handler;
  2310.     H4504Handler                     * h4504handler;
  2311.     H4506Handler                     * h4506handler;
  2312.     H45011Handler                    * h45011handler;
  2313.     OpalRFC2833                      * rfc2833handler;
  2314.     OpalT120Protocol                 * t120handler;
  2315.     OpalT38Protocol                  * t38handler;
  2316.  
  2317.  
  2318.     // The In-Band DTMF detector. This is used inside an audio filter which is
  2319.     // added to the audio channel.
  2320.     PDTMFDecoder                     dtmfDecoder;
  2321.  
  2322.   private:
  2323.     PChannel * SwapHoldMediaChannels(PChannel * newChannel);
  2324.  
  2325.     PMutex outerMutex;
  2326.     PMutex innerMutex;
  2327. };
  2328.  
  2329.  
  2330. PLIST(H323ConnectionList, H323Connection);
  2331. PDICTIONARY(H323ConnectionDict, PString, H323Connection);
  2332. PDICTIONARY(H323CallIdentityDict, PString, H323Connection);
  2333.  
  2334.  
  2335. #endif // __OPAL_H323CON_H
  2336.  
  2337.  
  2338. /////////////////////////////////////////////////////////////////////////////
  2339.