stun.h

/*
#################################################################################################
#   sP2P NAT Traversal/Peer-To-Peer networking API
#   
#   This file is part of comercial product. You can not use it in any way, redistribute it
#   in any way and/or modify it in any way unless you get right to do so. 
#
#   Use licence can only be acquired from:
#   ---------------------------------------------------
#      AS-CAL,raziskave in razvoj, d.o.o.   
#      Kongresni trg 9, 1000 Ljubljana - Slovenia   
#      Company ID: 3913147000   
#   ---------------------------------------------------
#   , or product legal successor.       
#  
#################################################################################################   
#   Ivan Milic
#   HOLEST Engineering 
#   www.holest.com
#   Belgrade, Serbia 
#   January, 2013
##################################################################################################
*/



#ifndef STUN_H
#define STUN_H

#define STUN_MAX_STRING 256
#define STUN_MAX_UNKNOWN_ATTRIBUTES 8
#define STUN_MAX_MESSAGE_SIZE 2048
#define STUN_PORT 3478


#include "Common.h"
#include "IPEndPoint.h"
#include "Uninetwork.h"
#include <list>
#include <map>
#include <set>

namespace sp2plib{

class SP2P_API STUN{
public:

    typedef enum NAT_Type
    {
        NAT_UdpBlocked = 0,

        NAT_OpenInternet = 255,

        NAT_SymmetricUdpFirewall = 20,

        NAT_FullCone = 200,

        NAT_RestrictedCone = 150,

        NAT_PortRestrictedCone = 100,

        NAT_Symmetric = 50,

        NAT_Unknown = 10
    } NAT_Type;

    struct StunResponse{
      NAT_Type NATType;
      IPEndPoint ReflectedEndPoint;
      ::std::list<sp2plib::UInt16> MappedPorts;
      ~StunResponse(){
          MappedPorts.clear();
          /*if(this->MappedPorts != NULL){
           delete this->MappedPorts;
          }*/
      }
    };
    
    static StunResponse Query(Socket sock, char* host, sp2plib::UInt16 port = STUN_PORT , sp2plib::UInt16 StunResponseTimeout = 450);
    
    static StunResponse Query(Socket sock, IP4Address srvAddr, sp2plib::UInt16 port = STUN_PORT  , sp2plib::UInt16 StunResponseTimeout = 450);

    static int PortQuery(::std::map< ::std::string,IPEndPoint> *result, Socket s, IPEndPoint stunEP, int maxWait = 2000);

    static int PortQueryUniquePorts(::std::set<sp2plib::UInt16> *result, Socket s, IPEndPoint stunEP, int maxWait = 2000);

    static ::std::string NATTypeName(NAT_Type NType);

private:

typedef enum StunAttributeType {
    SAT_MappedAddress    = 0x0001,
    SAT_ResponseAddress  = 0x0002,
    SAT_ChangeRequest    = 0x0003,
    SAT_SourceAddress    = 0x0004,
    SAT_ChangedAddress   = 0x0005,
    SAT_Username         = 0x0006,
    SAT_Password         = 0x0007,
    SAT_MessageIntegrity = 0x0008,
    SAT_ErrorCode        = 0x0009,
    SAT_UnknownAttribute = 0x000A,
    SAT_ReflectedFrom    = 0x000B,
    SAT_XorMappedAddress = 0x8020,
    SAT_XorOnly          = 0x0021,
    SAT_ServerName       = 0x8022,
    SAT_SecondaryAddress = 0x8050
} StunAttributeType;

typedef enum StunMessageType {
    SMT_BindRequestMsg               = 0x0001,
    SMT_BindResponseMsg              = 0x0101,
    SMT_BindErrorResponseMsg         = 0x0111,
    SMT_SharedSecretRequestMsg       = 0x0002,
    SMT_SharedSecretResponseMsg      = 0x0102,
    SMT_SharedSecretErrorResponseMsg = 0x0112  
} StunMessageType;

typedef struct 
{
    sp2plib::UInt16          Type;//StunMessageType
    sp2plib::UInt16          Length;
    sp2plib::UInt128         ID;
} StunMessageHeader;


typedef struct
{
    sp2plib::UInt16 Type;//StunAttributeType
    sp2plib::UInt16 Length;
} StunAttributeHeader;


typedef struct
{
    sp2plib::UInt8 pad;
    sp2plib::UInt8 family;
    IPEndPoint EndPoint;
} StunAttributeAddress;

typedef struct
{
    sp2plib::UInt32 value;
} StunAttributeChangeRequest;

typedef struct
{
    sp2plib::UInt16 pad; // all 0
    sp2plib::UInt8 errorClass;
    sp2plib::UInt8 number;
    char reason[STUN_MAX_STRING];
    sp2plib::UInt16 sizeReason;
} StunAttributeError;

typedef struct
{
    sp2plib::UInt16 attrType[STUN_MAX_UNKNOWN_ATTRIBUTES];
    sp2plib::UInt16 numAttributes;
} StunAttributeUnknown;

typedef struct
{
    char value[STUN_MAX_STRING];      
    sp2plib::UInt16 sizeValue;
} StunAttributeString;

typedef struct 
{
    StunMessageHeader Header;
    
    bool hasMappedAddress;
    StunAttributeAddress  mappedAddress;
    
    bool hasResponseAddress;
    StunAttributeAddress  responseAddress;
    
    bool hasChangeRequest;
    StunAttributeChangeRequest changeRequest;
    
    bool hasSourceAddress;
    StunAttributeAddress sourceAddress;
    
    bool hasChangedAddress;
    StunAttributeAddress changedAddress;
    
    bool hasUsername;
    StunAttributeString username;
    
    bool hasPassword;
    StunAttributeString password;
    
    bool hasErrorCode;
    StunAttributeError errorCode;
    
    bool hasUnknownAttributes;
    StunAttributeUnknown unknownAttributes;
    
    bool hasReflectedFrom;
    StunAttributeAddress reflectedFrom;

    bool hasXorMappedAddress;
    StunAttributeAddress  xorMappedAddress;
    
    bool xorOnly;

    bool hasServerName;
    StunAttributeString serverName;
      
    bool hasSecondaryAddress;
    StunAttributeAddress secondaryAddress;
} StunMessage; 


static const sp2plib::UInt32 ChangeIpFlag   = 0x04;
static const sp2plib::UInt32 ChangePortFlag = 0x02;
static const sp2plib::UInt8  IPv4Family = 0x01;
static const sp2plib::UInt8  IPv6Family = 0x02;
static const int HeaderSize = 20;


static StunMessage * new_DoTransaction(StunMessage * request, Socket sock, IPEndPoint *ServerEndPoint,sp2plib::UInt16 StunResponseTimeout);
static char* encode16(char* buf, sp2plib::UInt16 data);
static char* encode32(char* buf, sp2plib::UInt32 data);
static char* encode(char* buf, const char* data, unsigned int length);
static char* encodeAddress(char* ptr, sp2plib::UInt16 type,StunAttributeAddress Attribute);
static char* encodeChangeRequest(char* ptr, StunAttributeChangeRequest Attribute );
static char* encodeError(char* ptr, StunAttributeError Attribute);
static char* encodeUnknown(char* ptr, StunAttributeUnknown Attribute);
static char* encodeXorOnly(char* ptr);
static char* encodeString(char* ptr, sp2plib::UInt16 type, StunAttributeString Attribute);
static unsigned int serializeMessage( const StunMessage &message, 
                   char* buff, 
                   unsigned int buffLength,
                   const StunAttributeString *password = NULL
                   );
static bool ParseAddress( char* body, unsigned int headerLen,  StunAttributeAddress &result );
static bool ParseChangeRequest( char* body,  unsigned int headerLen,  StunAttributeChangeRequest &result );
static bool ParseError( char* body, unsigned int headerLen,  StunAttributeError &result );
static bool ParseUnknown( char* body, unsigned int headerLen,  StunAttributeUnknown &result );
static bool ParseString( char* body,  unsigned int headerLen,  StunAttributeString &result );
static bool ParseMessage( char* buff, unsigned int buffLength, StunMessage& message);
static bool CreateRequest( StunMessage* message, bool changePort, bool changeIp, sp2plib::UInt128 *ID = NULL);

};

}

#endif