h46018_h225.h

Go to the documentation of this file.

/*
 * h46018_h225.h
 *
 * H.460.18 H225 NAT Traversal class.
 *
 * h323plus library
 *
 * Copyright (c) 2008 ISVO (Asia) Pte. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the General Public License (the  "GNU License"), in which case the
 * provisions of GNU License are applicable instead of those
 * above. If you wish to allow use of your version of this file only
 * under the terms of the GNU License and not to allow others to use
 * your version of this file under the MPL, indicate your decision by
 * deleting the provisions above and replace them with the notice and
 * other provisions required by the GNU License. If you do not delete
 * the provisions above, a recipient may use your version of this file
 * under either the MPL or the GNU License."
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 *
 * The Initial Developer of the Original Code is ISVO (Asia) Pte. Ltd.
 *
 * Portions of this code were written with the assisance of funding from
 * triple-IT. http://www.triple-it.nl.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 28624 $
 * $Author: rjongbloed $
 * $Date: 2012-12-03 15:13:25 +1100 (Mon, 03 Dec 2012) $
 */

#ifndef OPAL_H46018_H225
#define OPAL_H46018_NAT

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#if OPAL_H460_NAT

#include <h323/h323pdu.h>


class H46018SignalPDU  : public H323SignalPDU
{
  public:
    H46018SignalPDU(const OpalGloballyUniqueID & callIdentifier);
};


class H323EndPoint;
class H46018Handler;

class H46018Transport  : public OpalTransportTCP
{
    PCLASSINFO(H46018Transport, OpalTransportTCP);

  public:
    enum PDUType {
      e_raw,
    };

    H46018Transport(
      H323EndPoint & endpoint        
    );

    ~H46018Transport();

    virtual PBoolean WritePDU(
      const PBYTEArray & pdu  
    );

    virtual PBoolean ReadPDU(
      PBYTEArray & pdu  
    );

    PBoolean HandleH46018SignallingChannelPDU();

    PBoolean HandleH46018SignallingSocket(H323SignalPDU & pdu);

    PBoolean InitialPDU(const OpalGloballyUniqueID & callIdentifier);

    PBoolean isCall() { return isConnected; };

    void ConnectionLost(PBoolean established);

    PBoolean IsConnectionLost();

    // Overrides
    virtual PBoolean Connect(const OpalGloballyUniqueID & callIdentifier);

    virtual PBoolean Close();

    virtual PBoolean IsListening() const;

    virtual PBoolean IsOpen () const;

    PBoolean CloseTransport() { return closeTransport; };

  protected:
     PMutex connectionsMutex;
     PMutex WriteMutex;
     PMutex IntMutex;
     PTimeInterval ReadTimeOut;
     PSyncPoint ReadMutex;

     H46018Handler * Feature;

     PBoolean   isConnected;
     PBoolean   remoteShutDown;
     PBoolean   closeTransport;
};


class H323EndPoint;
class PNatMethod_H46019;

class H46018Handler : public PObject  
{
    PCLASSINFO(H46018Handler, PObject);

  public:
    H46018Handler(H323EndPoint * ep);
    ~H46018Handler();

    void Enable();
    PBoolean IsEnabled();

    H323EndPoint * GetEndPoint();

    PBoolean CreateH225Transport(const PASN_OctetString & information);

    void H46024ADirect(bool reply, const PString & token);
        
  protected:    
    H323EndPoint * EP;
    PNatMethod_H46019 * nat;
    PString lastCallIdentifer;

    PMutex m_h46024aMutex;
    bool   m_h46024a;

  private:
    H323TransportAddress m_address;
    OpalGloballyUniqueID m_callId;
    PThread * SocketCreateThread;
    PDECLARE_NOTIFIER(PThread, H46018Handler, SocketThread);
    PBoolean m_h46018inOperation;
};


class PNatMethod_H46019  : public PNatMethod
{
    PCLASSINFO(PNatMethod_H46019,PNatMethod);

  public:
    PNatMethod_H46019();

    ~PNatMethod_H46019();

    static PString GetNatMethodName();
    virtual PString GetName() const;

    virtual PString GetServer() const;

    virtual PBoolean CreateSocketPair(
      PUDPSocket * & socket1,            
      PUDPSocket * & socket2,            
      const PIPSocket::Address & binding,  
      void * userData
    );

    virtual bool IsAvailable(const PIPSocket::Address & address);

    /* Set Available
        This will enable the natMethod to be enabled when opening the
        sockets
    */
    void SetAvailable();

    virtual void Activate(bool act)  { active = act; }

    PBoolean OpenSocket(PUDPSocket & socket, PortInfo & portInfo, const PIPSocket::Address & binding) const;

    void AttachHandler(H46018Handler * _handler);

  protected:
    virtual NatTypes InternalGetNatType(bool forced, const PTimeInterval & maxAge);

#if OPAL_H460_NAT

    void SetConnectionSockets(
      PUDPSocket * data,            
      PUDPSocket * control,                        
      H323Connection::SessionInformation * info    
    );
#endif
    
    PBoolean available;                    
    PBoolean active;                    
    H46018Handler * handler;            
};

#ifndef _WIN32_WCE
       PPLUGIN_STATIC_LOAD(H46019,PNatMethod);
#endif


class H46019UDPSocket : public PUDPSocket
{
    PCLASSINFO(H46019UDPSocket, PUDPSocket);
  public:
    H46019UDPSocket(
      H46018Handler & _handler,
      H323Connection::SessionInformation * info,
      bool _rtpSocket
    );

    ~H46019UDPSocket();

    PBoolean GetLocalAddress(Address & addr, WORD & port);


    void Allocate(
      const H323TransportAddress & keepalive, 
      unsigned _payload, 
      unsigned _ttl,
      unsigned _muxId
    );

    void Activate();

    void Activate(const H323TransportAddress & keepalive,    
      unsigned _payload,            
      unsigned _ttl,                
      unsigned _muxId
    );

    unsigned GetPingPayload();

    void SetPingPayLoad(unsigned val);

    unsigned GetTTL();

    void SetTTL(unsigned val);

    virtual PBoolean ReadFrom(
      void * buf,     
      PINDEX len,     
      Address & addr, 
      WORD & port     
    );

    virtual PBoolean WriteTo(
      const void * buf,     
      PINDEX len,           
      const Address & addr, 
      WORD port             
    );

    enum  probe_state {
        e_notRequired,        
        e_initialising,       
        e_idle,               
        e_probing,            
        e_verify_receiver,    
        e_verify_sender,      
        e_wait,               
        e_direct              
    };

    struct probe_packet {
        PUInt16b    Length;   // Length
        PUInt32b    SSRC;     // Time Stamp
        BYTE        name[4];  // Name is limited to 32 (4 Bytes)
        BYTE        cui[20];  // SHA-1 is always 160 (20 Bytes)
    };

    virtual void SetAlternateAddresses(const H323TransportAddress & address, const PString & cui);

    virtual void GetAlternateAddresses(H323TransportAddress & address, PString & cui);

    virtual PBoolean IsAlternateAddress(
        const Address & address,    
        WORD port                    
        );
    void H46024Adirect(bool starter);

    void H46024Bdirect(const H323TransportAddress & address);

  protected:

    // H.460.19 Keepalives
    void InitialiseKeepAlive();    
    void SendRTPPing(const PIPSocket::Address & ip, const WORD & port);
    void SendRTCPPing();
    PBoolean SendRTCPFrame(RTP_ControlFrame & report, const PIPSocket::Address & ip, WORD port);
    PMutex PingMutex;

    // H46024 Annex A support
    PBoolean ReceivedProbePacket(const RTP_ControlFrame & frame, bool & probe, bool & success);
    void BuildProbe(RTP_ControlFrame & report, bool reply);
    void StartProbe();
    void ProbeReceived(bool probe, const PIPSocket::Address & addr, WORD & port);
    void SetProbeState(probe_state newstate);
    int GetProbeState() const;
    probe_state m_state;
    PMutex probeMutex;

    virtual PBoolean Internal_WriteTo(
      const Slice * slices, 
      size_t nSlices,       
      const Address & addr, 
      WORD port             
    );
  
    virtual PBoolean Internal_WriteTo(
      const void * buf,     
      PINDEX len,           
      const Address & addr, 
      WORD port             
    );

  private:
    H46018Handler & m_Handler;
    unsigned m_Session;             
    PString m_Token;                
    OpalGloballyUniqueID m_CallId;  
    PString m_CUI;                  

    // H.460.19 Keepalives
    PIPSocket::Address keepip;      
    WORD keepport;                  
    unsigned keeppayload;           
    unsigned keepTTL;               
    PUInt32b muxId;                 
    WORD keepseqno;                 
    PTime * keepStartTime;          

    PDECLARE_NOTIFIER(PTimer, H46019UDPSocket, Ping);   
    PTimer    Keep;                                     

    // H46024 Annex A support
    PString m_CUIrem;                                   
    PIPSocket::Address m_locAddr;  WORD m_locPort;      
    PIPSocket::Address m_remAddr;  WORD m_remPort;      
    PIPSocket::Address m_detAddr;  WORD m_detPort;      
    PIPSocket::Address m_pendAddr;  WORD m_pendPort;    
    PDECLARE_NOTIFIER(PTimer, H46019UDPSocket, Probe);  
    PTimer m_Probe;                                     
    PINDEX m_probes;                                    
    DWORD SSRC;                                         
    PIPSocket::Address m_altAddr;  WORD m_altPort;      
    // H46024 Annex B support
    PBoolean    m_h46024b;

    bool rtpSocket;
};

#endif // OPAL_H460_NAT

#endif // OPAL_H46018_H225