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 / transports.h < prev    next >
C/C++ Source or Header  |  2003-04-10  |  29KB  |  927 lines
  1. /*
  2.  * transports.h
  3.  *
  4.  * H.323 protocol handler
  5.  *
  6.  * Open H323 Library
  7.  *
  8.  * Copyright (c) 1998-2000 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: transports.h,v $
  30.  * Revision 1.42  2003/04/10 09:44:55  robertj
  31.  * Added associated transport to new GetInterfaceAddresses() function so
  32.  *   interfaces can be ordered according to active transport links. Improves
  33.  *   interoperability.
  34.  * Replaced old listener GetTransportPDU() with GetInterfaceAddresses()
  35.  *   and H323SetTransportAddresses() functions.
  36.  *
  37.  * Revision 1.41  2003/04/10 01:03:25  craigs
  38.  * Added functions to access to lists of interfaces
  39.  *
  40.  * Revision 1.40  2003/03/21 05:24:02  robertj
  41.  * Added setting of remote port in UDP transport constructor.
  42.  *
  43.  * Revision 1.39  2003/02/06 04:29:23  robertj
  44.  * Added more support for adding things to H323TransportAddressArrays
  45.  *
  46.  * Revision 1.38  2002/11/21 06:39:56  robertj
  47.  * Changed promiscuous mode to be three way. Fixes race condition in gkserver
  48.  *   which can cause crashes or more PDUs to be sent to the wrong place.
  49.  *
  50.  * Revision 1.37  2002/11/10 08:10:43  robertj
  51.  * Moved constants for "well known" ports to better place (OPAL change).
  52.  *
  53.  * Revision 1.36  2002/09/16 01:14:15  robertj
  54.  * Added #define so can select if #pragma interface/implementation is used on
  55.  *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
  56.  *
  57.  * Revision 1.35  2002/07/22 09:40:15  robertj
  58.  * Added ability to automatically convert string arrays, lists sorted lists
  59.  *   directly to H323TransportAddressArray.
  60.  *
  61.  * Revision 1.34  2002/07/02 10:02:29  robertj
  62.  * Added H323TransportAddress::GetIpAddress() so don't have to provide port
  63.  *   when you don't need it as in GetIpAndPort(),.
  64.  *
  65.  * Revision 1.33  2002/06/28 03:34:25  robertj
  66.  * Fixed issues with address translation on gatekeeper RAS channel.
  67.  *
  68.  * Revision 1.32  2002/06/12 03:51:59  robertj
  69.  * Added function to compare two transport addresses in a more intelligent
  70.  *   way that strict string comparison. Takes into account wildcarding.
  71.  *
  72.  * Revision 1.31  2002/02/11 04:20:25  robertj
  73.  * Fixed documentation errors, thanks Horacio J. Pe±a
  74.  *
  75.  * Revision 1.30  2002/02/05 23:29:23  robertj
  76.  * Changed default for H.323 listener to reuse addresses.
  77.  *
  78.  * Revision 1.29  2001/12/22 01:48:12  robertj
  79.  * Added ability to use local and remote port from transport channel as well
  80.  *   as explicit port in H.245 address PDU setting routine.
  81.  * Added PrintOn() to listener and transport for tracing purposes.
  82.  *
  83.  * Revision 1.28  2001/07/17 04:44:29  robertj
  84.  * Partial implementation of T.120 and T.38 logical channels.
  85.  *
  86.  * Revision 1.27  2001/06/25 02:30:46  robertj
  87.  * Allowed TCP listener socket to be opened in non-exclusive mode
  88.  *   (ie SO_REUSEADDR) to avoid daemon restart problems.
  89.  *
  90.  * Revision 1.26  2001/06/22 00:14:14  robertj
  91.  * Added ConnectTo() function to conencto specific address.
  92.  * Added promiscuous mode for UDP channel.
  93.  *
  94.  * Revision 1.25  2001/05/17 06:37:02  robertj
  95.  * Added multicast gatekeeper discovery support.
  96.  *
  97.  * Revision 1.24  2001/04/09 08:43:39  robertj
  98.  * Added ability to get transport address for a listener.
  99.  *
  100.  * Revision 1.23  2001/03/02 06:59:57  robertj
  101.  * Enhanced the globally unique identifier class.
  102.  *
  103.  * Revision 1.22  2001/02/09 05:16:24  robertj
  104.  * Added #pragma interface for GNU C++.
  105.  *
  106.  * Revision 1.21  2001/01/23 05:08:04  robertj
  107.  * Fixed bug when trying to clear call while waiting on H.245 channel connect, thanks Yura Aksyonov.
  108.  *
  109.  * Revision 1.20  2000/10/20 06:18:58  robertj
  110.  * Fixed very small race condition on creating new connectionon incoming call.
  111.  * Fixed memory/socket leak if do TCP connect and don't send valid setup PDU.
  112.  *
  113.  * Revision 1.19  2000/10/04 05:59:09  robertj
  114.  * Minor reorganisation of the H.245 secondary channel start up to make it simpler
  115.  *    to override its behaviour.
  116.  *
  117.  * Revision 1.18  2000/09/25 12:59:16  robertj
  118.  * Added StartListener() function that takes a H323TransportAddress to start
  119.  *     listeners bound to specific interfaces.
  120.  *
  121.  * Revision 1.17  2000/09/22 01:35:03  robertj
  122.  * Added support for handling LID's that only do symmetric codecs.
  123.  *
  124.  * Revision 1.16  2000/06/07 05:47:55  robertj
  125.  * Added call forwarding.
  126.  *
  127.  * Revision 1.15  2000/05/22 05:21:36  robertj
  128.  * Fixed race condition where controlChannel variable could be used before set.
  129.  *
  130.  * Revision 1.14  2000/05/18 11:53:34  robertj
  131.  * Changes to support doc++ documentation generation.
  132.  *
  133.  * Revision 1.13  2000/05/08 14:07:26  robertj
  134.  * Improved the provision and detection of calling and caller numbers, aliases and hostnames.
  135.  *
  136.  * Revision 1.12  2000/05/02 04:32:25  robertj
  137.  * Fixed copyright notice comment.
  138.  *
  139.  * Revision 1.11  1999/11/06 05:37:44  robertj
  140.  * Complete rewrite of termination of connection to avoid numerous race conditions.
  141.  *
  142.  * Revision 1.10  1999/10/16 03:47:57  robertj
  143.  * Fixed termination of gatekeeper RAS thread problem
  144.  *
  145.  * Revision 1.9  1999/10/10 08:59:47  robertj
  146.  * Fixed race condition in connection shutdown
  147.  *
  148.  * Revision 1.8  1999/09/14 06:52:54  robertj
  149.  * Added better support for multi-homed client hosts.
  150.  *
  151.  * Revision 1.7  1999/09/10 09:43:59  robertj
  152.  * Removed attempt at determining local interface for gatekeeper, so still has problem on multi-homed hosts.
  153.  *
  154.  * Revision 1.6  1999/08/31 12:34:18  robertj
  155.  * Added gatekeeper support.
  156.  *
  157.  * Revision 1.5  1999/08/25 05:14:21  robertj
  158.  * Fixed problem with calling modal dialog from a background thread.
  159.  *
  160.  * Revision 1.4  1999/07/14 06:06:14  robertj
  161.  * Fixed termination problems (race conditions) with deleting connection object.
  162.  *
  163.  * Revision 1.3  1999/07/09 06:09:49  robertj
  164.  * Major implementation. An ENORMOUS amount of stuff added everywhere.
  165.  *
  166.  * Revision 1.2  1999/06/13 12:41:14  robertj
  167.  * Implement logical channel transmitter.
  168.  * Fixed H245 connect on receiving call.
  169.  *
  170.  * Revision 1.1  1999/06/09 05:26:20  robertj
  171.  * Major restructuring of classes.
  172.  *
  173.  */
  174.  
  175. #ifndef __TRANSPORTS_H
  176. #define __TRANSPORTS_H
  177.  
  178. #ifdef P_USE_PRAGMA
  179. #pragma interface
  180. #endif
  181.  
  182.  
  183. #include <ptlib/sockets.h>
  184.  
  185.  
  186. class H225_Setup_UUIE;
  187. class H225_TransportAddress;
  188. class H225_ArrayOf_TransportAddress;
  189. class H225_TransportAddress_ipAddress;
  190.  
  191. class H245_TransportAddress;
  192.  
  193. class H323SignalPDU;
  194. class H323RasPDU;
  195. class H323EndPoint;
  196. class H323Connection;
  197. class H323Listener;
  198. class H323Transport;
  199. class H323Gatekeeper;
  200.  
  201.  
  202.  
  203. ///////////////////////////////////////////////////////////////////////////////
  204.  
  205. /**String representation of a transport address.
  206.  */
  207.  
  208. class H323TransportAddress : public PString
  209. {
  210.   PCLASSINFO(H323TransportAddress, PString);
  211.   public:
  212.     H323TransportAddress() { }
  213.     H323TransportAddress(const char *);
  214.     H323TransportAddress(const PString &);
  215.     H323TransportAddress(const H225_TransportAddress &);
  216.     H323TransportAddress(const H245_TransportAddress &);
  217.     H323TransportAddress(const PIPSocket::Address &, WORD);
  218.  
  219.     BOOL SetPDU(H225_TransportAddress & pdu) const;
  220.     BOOL SetPDU(H245_TransportAddress & pdu) const;
  221.  
  222.     /**Determine if the two transport addresses are equivalent.
  223.       */
  224.     BOOL IsEquivalent(
  225.       const H323TransportAddress & address
  226.     );
  227.  
  228.     /**Extract the ip address from transport address.
  229.        Returns FALSE, if the address is not an IP transport address.
  230.       */
  231.     BOOL GetIpAddress(
  232.       PIPSocket::Address & ip
  233.     ) const;
  234.  
  235.     /**Extract the ip address and port number from transport address.
  236.        Returns FALSE, if the address is not an IP transport address.
  237.       */
  238.     BOOL GetIpAndPort(
  239.       PIPSocket::Address & ip,
  240.       WORD & port,
  241.       const char * proto = "tcp"
  242.     ) const;
  243.  
  244.     /**Translate the transport address to a more human readable form.
  245.        Returns the hostname if using IP.
  246.       */
  247.     PString GetHostName() const;
  248.  
  249.     /**Create a listener based on this transport address.
  250.  
  251.        For example an address of "ip$10.0.0.1:1720" would create a TCP
  252.        listening socket that would be bound to the specific interface
  253.        10.0.0.1 and listens on port 1720. Note that the address
  254.        "ip$*:1720" can be used to bind to INADDR_ANY.
  255.  
  256.        Also note that if the address has a trailing '+' character then the
  257.        socket will be bound using the REUSEADDR option.
  258.       */
  259.     H323Listener * CreateListener(
  260.       H323EndPoint & endpoint   /// Endpoint object for transport creation.
  261.     ) const;
  262.  
  263.     /**Create a listener compatible for this address type.
  264.        This is similar to CreateListener() but does not use the TSAP specified
  265.        in the H323Transport. For example an address of "ip$10.0.0.1:1720"
  266.        would create a TCP listening socket that would be bound to the specific
  267.        interface 10.0.0.1 but listens on a random OS allocated port number.
  268.       */
  269.     H323Listener * CreateCompatibleListener(
  270.       H323EndPoint & endpoint   /// Endpoint object for transport creation.
  271.     ) const;
  272.  
  273.     /**Create a transport suitable for this address type.
  274.       */
  275.     H323Transport * CreateTransport(
  276.       H323EndPoint & endpoint   /// Endpoint object for transport creation.
  277.     ) const;
  278.  
  279.   protected:
  280.     void Validate();
  281. };
  282.  
  283.  
  284. PDECLARE_ARRAY(H323TransportAddressArray, H323TransportAddress)
  285.   public:
  286.     H323TransportAddressArray(
  287.       const H323TransportAddress & address
  288.     ) { AppendAddress(address); }
  289.     H323TransportAddressArray(
  290.       const H225_ArrayOf_TransportAddress & addresses
  291.     );
  292.     H323TransportAddressArray(
  293.       const PStringArray & array
  294.     ) { AppendStringCollection(array); }
  295.     H323TransportAddressArray(
  296.       const PStringList & list
  297.     ) { AppendStringCollection(list); }
  298.     H323TransportAddressArray(
  299.       const PSortedStringList & list
  300.     ) { AppendStringCollection(list); }
  301.  
  302.     void AppendString(
  303.       const char * address
  304.     );
  305.     void AppendString(
  306.       const PString & address
  307.     );
  308.     void AppendAddress(
  309.       const H323TransportAddress & address
  310.     );
  311.  
  312.   protected:
  313.     void AppendStringCollection(
  314.       const PCollection & coll
  315.     );
  316. };
  317.  
  318.  
  319. /**This class describes a "listener" on a transport protocol.
  320.    A "listener" is an object that listens for incoming connections on the
  321.    particular transport. It is executed as a separate thread.
  322.  
  323.    The Main() function is used to handle incoming H.323 connections and
  324.    dispatch them in new threads based on the actual H323Transport class. This
  325.    is defined in the descendent class that knows what the low level transport
  326.    is, eg H323ListenerIP for the TCP/IP protocol.
  327.  
  328.    An application may create a descendent off this class and override
  329.    functions as required for operating the channel protocol.
  330.  */
  331. class H323Listener : public PThread
  332. {
  333.   PCLASSINFO(H323Listener, PThread);
  334.  
  335.   public:
  336.   /**@name Construction */
  337.   //@{
  338.     /**Create a new listener.
  339.      */
  340.     H323Listener(
  341.       H323EndPoint & endpoint      /// Endpoint instance for channel
  342.     );
  343.   //@}
  344.  
  345.   /**@name Overrides from PObject */
  346.   //@{
  347.     virtual void PrintOn(
  348.       ostream & strm
  349.     ) const;
  350.   //@}
  351.  
  352.   /**@name Operations */
  353.   //@{
  354.     /** Open the listener.
  355.       */
  356.     virtual BOOL Open() = 0;
  357.  
  358.     /**Stop the listener thread and no longer accept incoming connections.
  359.      */
  360.     virtual BOOL Close() = 0;
  361.  
  362.     /**Accept a new incoming transport.
  363.       */
  364.     virtual H323Transport * Accept(
  365.       const PTimeInterval & timeout  /// Time to wait for incoming connection
  366.     ) = 0;
  367.  
  368.     /**Get the local transport address on which this listener may be accessed.
  369.       */
  370.     virtual H323TransportAddress GetTransportAddress() const = 0;
  371.  
  372.     /**Set up a transport address PDU for bidirectional logical channels.
  373.       */
  374.     virtual BOOL SetUpTransportPDU(
  375.       H245_TransportAddress & pdu,         /// Transport addresses listening on
  376.       const H323Transport & associatedTransport /// Associated transport for precendence and translation
  377.     ) = 0;
  378.   //@}
  379.  
  380.   protected:
  381.     H323EndPoint & endpoint;  /// Endpoint that owns the listener.
  382. };
  383.  
  384.  
  385. PLIST(H323ListenerList, H323Listener);
  386.  
  387.  
  388. /** Return a list of transport addresses corresponding to a listener list
  389.   */
  390. H323TransportAddressArray H323GetInterfaceAddresses(
  391.   const H323ListenerList & listeners, /// List of listeners
  392.   BOOL excludeLocalHost = TRUE,       /// Flag to exclude 127.0.0.1
  393.   H323Transport * associatedTransport = NULL
  394.                           /// Associated transport for precedence and translation
  395. );
  396.  
  397. H323TransportAddressArray H323GetInterfaceAddresses(
  398.   const H323TransportAddress & addr,  /// Possible INADDR_ANY address
  399.   BOOL excludeLocalHost = TRUE,       /// Flag to exclude 127.0.0.1
  400.   H323Transport * associatedTransport = NULL
  401.                           /// Associated transport for precedence and translation
  402. );
  403.  
  404. /**Set the PDU field for the list of transport addresses
  405.   */
  406. void H323SetTransportAddresses(
  407.   const H323Transport & associatedTransport,   /// Transport for NAT address translation
  408.   const H323TransportAddressArray & addresses, /// Addresses to set
  409.   H225_ArrayOf_TransportAddress & pdu          /// List of PDU transport addresses
  410. );
  411.  
  412.  
  413. /**This class describes a I/O transport protocol..
  414.    A "transport" is an object that listens for incoming connections on the
  415.    particular transport.
  416.  */
  417. class H323Transport : public PIndirectChannel
  418. {
  419.   PCLASSINFO(H323Transport, PIndirectChannel);
  420.  
  421.   public:
  422.   /**@name Construction */
  423.   //@{
  424.     /**Create a new transport channel.
  425.      */
  426.     H323Transport(H323EndPoint & endpoint);
  427.     ~H323Transport();
  428.   //@}
  429.  
  430.   /**@name Overrides from PObject */
  431.   //@{
  432.     virtual void PrintOn(
  433.       ostream & strm
  434.     ) const;
  435.   //@}
  436.  
  437.   /**@name Operations */
  438.   //@{
  439.     /**Get the transport address of the local endpoint.
  440.       */
  441.     virtual H323TransportAddress GetLocalAddress() const = 0;
  442.  
  443.     /**Get the transport address of the remote endpoint.
  444.       */
  445.     virtual H323TransportAddress GetRemoteAddress() const = 0;
  446.  
  447.     /**Set remote address to connect to.
  448.        Note that this does not necessarily initiate a transport level
  449.        connection, but only indicates where to connect to. The actual
  450.        connection is made by the Connect() function.
  451.       */
  452.     virtual BOOL SetRemoteAddress(
  453.       const H323TransportAddress & address
  454.     ) = 0;
  455.  
  456.     /**Connect to the remote address.
  457.       */
  458.     virtual BOOL Connect() = 0;
  459.  
  460.     /**Connect to the specified address.
  461.       */
  462.     BOOL ConnectTo(
  463.       const H323TransportAddress & address
  464.     ) { return SetRemoteAddress(address) && Connect(); }
  465.  
  466.     /**Close the channel.
  467.       */
  468.     virtual BOOL Close();
  469.  
  470.     /**Check that the transport address PDU is compatible with transport.
  471.       */
  472.     virtual BOOL IsCompatibleTransport(
  473.       const H225_TransportAddress & pdu
  474.     ) const;
  475.  
  476.     /**Set up a transport address PDU for RAS channel.
  477.       */
  478.     virtual void SetUpTransportPDU(
  479.       H225_TransportAddress & pdu,
  480.       BOOL localTsap
  481.     ) const;
  482.  
  483.     enum {
  484.       UseLocalTSAP = 0x10001,
  485.       UseRemoteTSAP
  486.     };
  487.  
  488.     /**Set up a transport address PDU for logical channel.
  489.        If tsap is UseLocalTSAP or UseRemoteTSAP then the local or remote port
  490.        of the transport is used, otherwise the explicit port number is used.
  491.       */
  492.     virtual void SetUpTransportPDU(
  493.       H245_TransportAddress & pdu,
  494.       unsigned tsap
  495.     ) const;
  496.  
  497.     /// Promiscious modes for transport
  498.     enum PromisciousModes {
  499.       AcceptFromRemoteOnly,
  500.       AcceptFromAnyAutoSet,
  501.       AcceptFromAny,
  502.       NumPromisciousModes
  503.     };
  504.  
  505.     /**Set read to promiscuous mode.
  506.        Normally only reads from the specifed remote address are accepted. This
  507.        flag allows packets to be accepted from any remote, provided the
  508.        underlying protocol can do so. For example TCP will do nothing.
  509.  
  510.        The Read() call may optionally set the remote address automatically to
  511.        whatever the sender host of the last received message was.
  512.  
  513.        Default behaviour does nothing.
  514.       */
  515.     virtual void SetPromiscuous(
  516.       PromisciousModes promiscuous
  517.     );
  518.  
  519.     /**Get the transport address of the last received PDU.
  520.  
  521.        Default behaviour returns GetRemoteAddress().
  522.       */
  523.     virtual H323TransportAddress GetLastReceivedAddress() const;
  524.  
  525.     /**Read a protocol data unit from the transport.
  526.        This will read using the transports mechanism for PDU boundaries, for
  527.        example UDP is a single Read() call, while for TCP there is a TPKT
  528.        header that indicates the size of the PDU.
  529.       */
  530.     virtual BOOL ReadPDU(
  531.       PBYTEArray & pdu   /// PDU read from transport
  532.     ) = 0;
  533.  
  534.     /**Write a protocol data unit from the transport.
  535.        This will write using the transports mechanism for PDU boundaries, for
  536.        example UDP is a single Write() call, while for TCP there is a TPKT
  537.        header that indicates the size of the PDU.
  538.       */
  539.     virtual BOOL WritePDU(
  540.       const PBYTEArray & pdu  /// PDU to write
  541.     ) = 0;
  542.   //@}
  543.  
  544.   /**@name Signalling Channel */
  545.   //@{
  546.     /**Wait for first PDU and find/create connection object.
  547.        If returns FALSE, then the transport is deleted by the calling thread.
  548.       */
  549.     BOOL HandleFirstSignallingChannelPDU();
  550.   //@}
  551.  
  552.   /**@name Control Channel */
  553.   //@{
  554.     /**Begin the opening of a control channel.
  555.        This sets up the channel so that the remote endpoint can connect back
  556.        to this endpoint. This would be called on the signalling channel
  557.        instance of a H323Transport.
  558.       */
  559.     virtual H323Transport * CreateControlChannel(
  560.       H323Connection & connection
  561.     );
  562.  
  563.     /**Finish the opening of a control channel.
  564.        This waits for the connect backfrom the remote endpoint, completing the
  565.        control channel open sequence.
  566.       */
  567.     virtual BOOL AcceptControlChannel(
  568.       H323Connection & connection
  569.     );
  570.  
  571.     /**Connect the control channel.
  572.       */
  573.     virtual void StartControlChannel(
  574.       H323Connection & connection
  575.     );
  576.   //@}
  577.  
  578.   /**@name RAS Channel */
  579.   //@{
  580.     /**Discover a Gatekeeper on the network.
  581.        This locates a gatekeeper on the network and associates this transport
  582.        object with packet exchange with that gatekeeper.
  583.       */
  584.     virtual BOOL DiscoverGatekeeper(
  585.       H323Gatekeeper & gk,                  /// Gatekeeper to set on discovery.
  586.       H323RasPDU & pdu,                     /// GatekeeperRequest PDU
  587.       const H323TransportAddress & address  /// Address of gatekeeper (if present)
  588.     );
  589.   //@}
  590.  
  591.  
  592.   /**@name Member variable access */
  593.   //@{
  594.     /**Get the associated endpoint to this transport.
  595.       */
  596.     H323EndPoint & GetEndPoint() const { return endpoint; }
  597.  
  598.     /**Attach a thread to the transport.
  599.       */
  600.     void AttachThread(
  601.       PThread * thread
  602.     );
  603.  
  604.     /**Wait for associated thread to terminate.
  605.       */
  606.     void CleanUpOnTermination();
  607.   //@}
  608.  
  609.   protected:
  610.     H323EndPoint & endpoint;    /// Endpoint that owns the listener.
  611.     PThread      * thread;      /// Thread handling the transport
  612. };
  613.  
  614.  
  615.  
  616. ///////////////////////////////////////////////////////////////////////////////
  617. // Transport classes for IP
  618.  
  619. /**This class represents a particular H323 transport using IP.
  620.    It is used by the TCP and UDP transports.
  621.  */
  622. class H323TransportIP : public H323Transport
  623. {
  624.   PCLASSINFO(H323TransportIP, H323Transport);
  625.  
  626.   public:
  627.     /**Create a new transport channel.
  628.      */
  629.     H323TransportIP(
  630.       H323EndPoint & endpoint,    /// H323 End Point object
  631.       PIPSocket::Address binding, /// Local interface to use
  632.       WORD remPort                /// Remote port to use
  633.     );
  634.  
  635.     /**Get the transport dependent name of the local endpoint.
  636.       */
  637.     virtual H323TransportAddress GetLocalAddress() const;
  638.  
  639.     /**Get the transport dependent name of the remote endpoint.
  640.       */
  641.     virtual H323TransportAddress GetRemoteAddress() const;
  642.  
  643.     /**Check that the transport address PDU is compatible with transport.
  644.       */
  645.     virtual BOOL IsCompatibleTransport(
  646.       const H225_TransportAddress & pdu
  647.     ) const;
  648.  
  649.     /**Set up a transport address PDU for RAS channel.
  650.       */
  651.     virtual void SetUpTransportPDU(
  652.       H225_TransportAddress & pdu,
  653.       BOOL localTsap
  654.     ) const;
  655.  
  656.     /**Set up a transport address PDU for logical channel.
  657.       */
  658.     virtual void SetUpTransportPDU(
  659.       H245_TransportAddress & pdu,
  660.       unsigned tsap
  661.     ) const;
  662.  
  663.  
  664.   protected:
  665.     PIPSocket::Address localAddress;  // Address of the local interface
  666.     WORD               localPort;
  667.     PIPSocket::Address remoteAddress; // Address of the remote host
  668.     WORD               remotePort;
  669. };
  670.  
  671.  
  672. ///////////////////////////////////////////////////////////////////////////////
  673. // Transport classes for TCP/IP
  674.  
  675. /**This class manages H323 connections using TCP/IP transport.
  676.  */
  677. class H323ListenerTCP : public H323Listener
  678. {
  679.   PCLASSINFO(H323ListenerTCP, H323Listener);
  680.  
  681.   public:
  682.     /**Create a new listener for the TCP/IP protocol.
  683.      */
  684.     H323ListenerTCP(
  685.       H323EndPoint & endpoint,    /// Endpoint instance for channel
  686.       PIPSocket::Address binding, /// Local interface to listen on
  687.       WORD port,                  /// TCP port to listen for connections
  688.       BOOL exclusive = FALSE      /// Fail if listener port in use
  689.     );
  690.  
  691.     /** Destroy the listener thread.
  692.       */
  693.     ~H323ListenerTCP();
  694.     
  695.   // Overrides from H323Listener
  696.     /** Open the listener.
  697.       */
  698.     virtual BOOL Open();
  699.  
  700.     /**Stop the listener thread and no longer accept incoming connections.
  701.      */
  702.     virtual BOOL Close();
  703.  
  704.     /**Accept a new incoming transport.
  705.       */
  706.     virtual H323Transport * Accept(
  707.       const PTimeInterval & timeout  /// Time to wait for incoming connection
  708.     );
  709.  
  710.     /**Get the local transport address on which this listener may be accessed.
  711.       */
  712.     virtual H323TransportAddress GetTransportAddress() const;
  713.  
  714.     /**Set up a transport address PDU for bidirectional logical channels.
  715.       */
  716.     virtual BOOL SetUpTransportPDU(
  717.       H245_TransportAddress & pdu,        /// Transport addresses listening on
  718.       const H323Transport & associatedTransport /// Associated transport for precendence and translation
  719.     );
  720.  
  721.     WORD GetListenerPort() const { return listener.GetPort(); }
  722.  
  723.  
  724.   protected:
  725.     /**Handle incoming H.323 connections and dispatch them in new threads
  726.        based on the H323Transport class. This is defined in the descendent
  727.        class that knows what the low level transport is, eg H323ListenerIP
  728.        for the TCP/IP protocol.
  729.  
  730.        Note this function does not return until the Close() function is called
  731.        or there is some other error.
  732.      */
  733.     virtual void Main();
  734.  
  735.  
  736.     PTCPSocket listener;
  737.     PIPSocket::Address localAddress;
  738.     BOOL exclusiveListener;
  739. };
  740.  
  741.  
  742. /**This class represents a particular H323 transport using TCP/IP.
  743.  */
  744. class H323TransportTCP : public H323TransportIP
  745. {
  746.   PCLASSINFO(H323TransportTCP, H323TransportIP);
  747.  
  748.   public:
  749.     /**Create a new transport channel.
  750.      */
  751.     H323TransportTCP(
  752.       H323EndPoint & endpoint,    /// H323 End Point object
  753.       PIPSocket::Address binding = INADDR_ANY, /// Local interface to use
  754.       BOOL listen = FALSE         /// Flag for need to wait for remote to connect
  755.     );
  756.  
  757.     /**Destroy transport channel.
  758.      */
  759.     ~H323TransportTCP();
  760.  
  761.     /**Set default remote address to connect to.
  762.        Note that this does not necessarily initiate a transport level
  763.        connection, but only indicates where to connect to. The actual
  764.        connection is made by the Connect() function.
  765.       */
  766.     virtual BOOL SetRemoteAddress(
  767.       const H323TransportAddress & address
  768.     );
  769.  
  770.     /**Connect to the remote party.
  771.       */
  772.     virtual BOOL Connect();
  773.  
  774.     /**Close the channel.
  775.       */
  776.     virtual BOOL Close();
  777.  
  778.     /**Read a protocol data unit from the transport.
  779.        This will read using the transports mechanism for PDU boundaries, for
  780.        example UDP is a single Read() call, while for TCP there is a TPKT
  781.        header that indicates the size of the PDU.
  782.       */
  783.     BOOL ReadPDU(
  784.       PBYTEArray & pdu   /// PDU read from transport
  785.     );
  786.  
  787.     /**Write a protocol data unit from the transport.
  788.        This will write using the transports mechanism for PDU boundaries, for
  789.        example UDP is a single Write() call, while for TCP there is a TPKT
  790.        header that indicates the size of the PDU.
  791.       */
  792.     BOOL WritePDU(
  793.       const PBYTEArray & pdu  /// PDU to write
  794.     );
  795.  
  796.     /**Begin the opening of a control channel.
  797.        This sets up the channel so that the remote endpoint can connect back
  798.        to this endpoint.
  799.       */
  800.     virtual H323Transport * CreateControlChannel(
  801.       H323Connection & connection
  802.     );
  803.  
  804.     /**Finish the opening of a control channel.
  805.        This waits for the connect backfrom the remote endpoint, completing the
  806.        control channel open sequence.
  807.       */
  808.     virtual BOOL AcceptControlChannel(
  809.       H323Connection & connection
  810.     );
  811.  
  812.     /**Indicate we are waiting from remote to connect back to us.
  813.       */
  814.     BOOL IsListening() const;
  815.  
  816.  
  817.   protected:
  818.     /**This callback is executed when the Open() function is called with
  819.        open channels. It may be used by descendent channels to do any
  820.        handshaking required by the protocol that channel embodies.
  821.  
  822.        The default behaviour is to simply return TRUE.
  823.  
  824.        @return
  825.        Returns TRUE if the protocol handshaking is successful.
  826.      */
  827.     virtual BOOL OnOpen();
  828.  
  829.  
  830.     PTCPSocket * h245listener;
  831. };
  832.  
  833.  
  834. ///////////////////////////////////////////////////////////////////////////////
  835. // Transport classes for UDP/IP
  836.  
  837. /**This class represents a particular H323 transport using UDP/IP.
  838.  */
  839. class H323TransportUDP : public H323TransportIP
  840. {
  841.   PCLASSINFO(H323TransportUDP, H323TransportIP);
  842.  
  843.   public:
  844.     /**Create a new transport channel.
  845.      */
  846.     H323TransportUDP(
  847.       H323EndPoint & endpoint,                  /// H323 End Point object
  848.       PIPSocket::Address binding = INADDR_ANY,  /// Local interface to listen on
  849.       WORD localPort = 0,                       /// Local port to listen on
  850.       WORD remotePort = 0                       /// Remote port to connect on
  851.     );
  852.     ~H323TransportUDP();
  853.  
  854.     /**Set default remote address to connect to.
  855.        Note that this does not necessarily initiate a transport level
  856.        connection, but only indicates where to connect to. The actual
  857.        connection is made by the Connect() function.
  858.       */
  859.     virtual BOOL SetRemoteAddress(
  860.       const H323TransportAddress & address
  861.     );
  862.  
  863.     /**Connect to the remote party.
  864.       */
  865.     virtual BOOL Connect();
  866.  
  867.     /**Set read to promiscuous mode.
  868.        Normally only reads from the specifed remote address are accepted. This
  869.        flag allows packets to be accepted from any remote, provided the
  870.        underlying protocol can do so.
  871.  
  872.        The Read() call may optionally set the remote address automatically to
  873.        whatever the sender host of the last received message was.
  874.  
  875.        Default behaviour sets the internal flag, so that Read() operates as
  876.        described.
  877.       */
  878.     virtual void SetPromiscuous(
  879.       PromisciousModes promiscuous
  880.     );
  881.  
  882.     /**Get the transport address of the last received PDU.
  883.  
  884.        Default behaviour returns the lastReceivedAddress member variable.
  885.       */
  886.     virtual H323TransportAddress GetLastReceivedAddress() const;
  887.  
  888.     /**Read a protocol data unit from the transport.
  889.        This will read using the transports mechanism for PDU boundaries, for
  890.        example UDP is a single Read() call, while for TCP there is a TPKT
  891.        header that indicates the size of the PDU.
  892.       */
  893.     virtual BOOL ReadPDU(
  894.       PBYTEArray & pdu   /// PDU read from transport
  895.     );
  896.  
  897.     /**Write a protocol data unit from the transport.
  898.        This will write using the transports mechanism for PDU boundaries, for
  899.        example UDP is a single Write() call, while for TCP there is a TPKT
  900.        header that indicates the size of the PDU.
  901.       */
  902.     virtual BOOL WritePDU(
  903.       const PBYTEArray & pdu  /// PDU to write
  904.     );
  905.  
  906.     /**Discover a Gatekeeper on the local network.
  907.        This locates a gatekeeper on the network and associates this transport
  908.        object with packet exchange with that gatekeeper. This broadcasts a UDP
  909.        packet on the local network to find the gatekeeper's IP address.
  910.       */
  911.     virtual BOOL DiscoverGatekeeper(
  912.       H323Gatekeeper & gk,                  /// Gatekeeper to set on discovery.
  913.       H323RasPDU & pdu,                     /// GatekeeperRequest PDU
  914.       const H323TransportAddress & address  /// Address of gatekeeper (if present)
  915.     );
  916.  
  917.   protected:
  918.     PromisciousModes     promiscuousReads;
  919.     H323TransportAddress lastReceivedAddress;
  920. };
  921.  
  922.  
  923. #endif // __TRANSPORTS_H
  924.  
  925.  
  926. /////////////////////////////////////////////////////////////////////////////
  927.