pstun.h

Go to the documentation of this file.

/*
 * pstun.h
 *
 * STUN client
 *
 * Portable Windows Library
 *
 * Copyright (c) 2003 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 20766 $
 * $Author: rjongbloed $
 * $Date: 2008-08-29 06:41:59 +0000 (Fri, 29 Aug 2008) $
 */

#ifndef _PSTUN_H
#define _PSTUN_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <ptclib/pnat.h>
#include <ptlib/sockets.h>


class PSTUNUDPSocket : public PUDPSocket
{
  PCLASSINFO(PSTUNUDPSocket, PUDPSocket);
  public:
    PSTUNUDPSocket();

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

  protected:
    PIPSocket::Address externalIP;

  friend class PSTUNClient;
};


class PSTUNClient : public PNatMethod
{
  PCLASSINFO(PSTUNClient, PNatMethod);
  public:
    enum {
      DefaultPort = 3478
    };

    PSTUNClient();

    PSTUNClient(
      const PString & server,
      WORD portBase = 0,
      WORD portMax = 0,
      WORD portPairBase = 0,
      WORD portPairMax = 0
    );
    PSTUNClient(
      const PIPSocket::Address & serverAddress,
      WORD serverPort = DefaultPort,
      WORD portBase = 0,
      WORD portMax = 0,
      WORD portPairBase = 0,
      WORD portPairMax = 0
    );


    void Initialise(
      const PString & server,
      WORD portBase = 0, 
      WORD portMax = 0,
      WORD portPairBase = 0, 
      WORD portPairMax = 0
    );

    static PStringList GetNatMethodName() { return PStringList("STUN"); }

    virtual PString GetName() const { return "STUN"; }

    virtual bool GetServerAddress(
      PIPSocket::Address & address,   
      WORD & port                     
    ) const;

    PBoolean SetServer(
      const PString & server
    );

    PBoolean SetServer(
      const PIPSocket::Address & serverAddress,
      WORD serverPort = 0
    );

    enum NatTypes {
      UnknownNat,
      OpenNat,
      ConeNat,
      RestrictedNat,
      PortRestrictedNat,
      SymmetricNat,
      SymmetricFirewall,
      BlockedNat,
      PartialBlockedNat,
      NumNatTypes
    };

    NatTypes GetNatType(
      PBoolean force = PFalse    
    );

    PString GetNatTypeName(
      PBoolean force = PFalse    
    ) { return GetNatTypeString(GetNatType(force)); }

    static PString GetNatTypeString(
      NatTypes type   
    );

    RTPSupportTypes GetRTPSupport(
      PBoolean force = PFalse    
    );

    virtual PBoolean GetExternalAddress(
      PIPSocket::Address & externalAddress, 
      const PTimeInterval & maxAge = 1000   
    );

    virtual bool GetInterfaceAddress(
      PIPSocket::Address & internalAddress
    ) const;

    void InvalidateCache();

    PBoolean CreateSocket(
      PUDPSocket * & socket,
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      WORD localPort = 0
    );

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

    const PTimeInterval GetTimeout() const { return replyTimeout; }

    void SetTimeout(
      const PTimeInterval & timeout   
    ) { replyTimeout = timeout; }

    PINDEX GetRetries() const { return pollRetries; }

    void SetRetries(
      PINDEX retries    
    ) { pollRetries = retries; }

    PINDEX GetSocketsForPairing() const { return numSocketsForPairing; }

    void SetSocketsForPairing(
      PINDEX numSockets   
    ) { numSocketsForPairing = numSockets; }

    virtual bool IsAvailable(
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny()  
    );

  protected:
    PString            serverHost;
    WORD               serverPort;
    PTimeInterval      replyTimeout;
    PINDEX             pollRetries;
    PINDEX             numSocketsForPairing;

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

    NatTypes           natType;
    PIPSocket::Address cachedServerAddress;
    PIPSocket::Address cachedExternalAddress;
    PIPSocket::Address interfaceAddress;
    PTime              timeAddressObtained;
};


inline ostream & operator<<(ostream & strm, PSTUNClient::NatTypes type) { return strm << PSTUNClient::GetNatTypeString(type); }

typedef PSTUNClient PNatMethod_STUN;
PWLIB_STATIC_LOAD_PLUGIN(STUN, PNatMethod);


#endif // _PSTUN_H


// End of file ////////////////////////////////////////////////////////////////

---