ies.h

Go to the documentation of this file.

/*
 *
 * Inter Asterisk Exchange 2
 * 
 * The classes used to hold Information Elements.
 * 
 * Open Phone Abstraction Library (OPAL)
 *
 * Copyright (c) 2005 Indranet Technologies 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 Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Indranet Technologies Ltd.
 *
 * The author of this code is Derek J Smithies
 *
 * $Revision: 24625 $
 * $Author: dereksmithies $
 * $Date: 2010-08-08 17:41:30 -0500 (Sun, 08 Aug 2010) $
 */

#ifndef OPAL_IAX2_IES_H
#define OPAL_IAX2_IES_H

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

#include <opal/buildopts.h>

#if OPAL_IAX2

#include <ptlib/sockets.h>
#include <iax2/iedata.h>

#ifdef P_USE_PRAGMA
#pragma interface
#endif


class IAX2Ie;
class IAX2Encryption;

class IAX2Ie : public PObject
{ 
  PCLASSINFO(IAX2Ie, PObject);
 public:
  enum IAX2IeTypeCode {    
    ie_calledNumber      = 1,     
    ie_callingNumber     = 2,     
    ie_callingAni        = 3,     
    ie_callingName       = 4,     
    ie_calledContext     = 5,     
    ie_userName          = 6,     
    ie_password          = 7,     
    ie_capability        = 8,     
    ie_format            = 9,     
    ie_language          = 10,    
    ie_version           = 11,    
    ie_adsicpe           = 12,    
    ie_dnid              = 13,    
    ie_authMethods       = 14,    
    ie_challenge         = 15,    
    ie_md5Result         = 16,    
    ie_rsaResult         = 17,    
    ie_apparentAddr      = 18,    
    ie_refresh           = 19,    
    ie_dpStatus          = 20,    
    ie_callNo            = 21,    
    ie_cause             = 22,    
    ie_iaxUnknown        = 23,    
    ie_msgCount          = 24,    
    ie_autoAnswer        = 25,    
    ie_musicOnHold       = 26,    
    ie_transferId        = 27,    
    ie_rdnis             = 28,    
    ie_provisioning      = 29,    
    ie_aesProvisioning   = 30,    
    ie_dateTime          = 31,    
    ie_deviceType        = 32,    
    ie_serviceIdent      = 33,    
    ie_firmwareVer       = 34,    
    ie_fwBlockDesc       = 35,    
    ie_fwBlockData       = 36,    
    ie_provVer           = 37,    
    ie_callingPres       = 38,    
    ie_callingTon        = 39,    
    ie_callingTns        = 40,    
    ie_samplingRate      = 41,    
    ie_causeCode         = 42,    
    ie_encryption        = 43,    
    ie_encKey            = 44,    
    ie_codecPrefs        = 45,    
    ie_recJitter         = 46,    
    ie_recLoss           = 47,    
    ie_recPackets        = 48,    
    ie_recDelay          = 49,    
    ie_recDropped        = 50,    
    ie_recOoo            = 51,    
    ie_variable          = 52,    
    ie_ospToken          = 53,    
    ie_callToken         = 54,    
    ie_capability2       = 55,    
    ie_format2           = 56,    
    ie_countEntries              
  };
  
  
  IAX2Ie();
  
  virtual ~IAX2Ie() { };
  
  static IAX2Ie *BuildInformationElement(BYTE _typeCode, BYTE length, BYTE *srcData);     
  
  virtual PBoolean IsValid() { return validData; }
  
  virtual BYTE GetLengthOfData() { return 0; }
  
  int GetBinarySize() { return 2 + GetLengthOfData(); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return 255; }
  
  void SetData(int &/*newData*/) { PAssertAlways("Ie class cannnot set data value"); };
  
  int ReadData() { PAssertAlways("Ie class cannot read the internal data value"); return 0; };
  
  void WriteBinary(void *data, PINDEX & writeIndex);
  
  virtual void StoreDataIn(IAX2IeData &/*res*/) { PAssertAlways(PUnimplementedFunction); }     
  
 protected:
  virtual void WriteBinary(BYTE * /*data*/) { PAssertAlways(PUnimplementedFunction); }
  
  PBoolean   validData;
};


class IAX2IeInvalidElement : public IAX2Ie
{
  PCLASSINFO(IAX2IeInvalidElement, IAX2Ie);
 public:
  IAX2IeInvalidElement() : IAX2Ie() {};
  
  virtual BYTE GetlengthOfData() { return 0; }
  
  virtual void PrintOn(ostream & str) const
    { str << "Invlalid Information Element" << endl; }
 protected:
  virtual void WriteBinary(BYTE * /*data*/) {  }
};

class IAX2IeNone : public IAX2Ie
{
  PCLASSINFO(IAX2IeNone, IAX2Ie);
  
  IAX2IeNone(BYTE length, BYTE *srcData);     
  
  IAX2IeNone() : IAX2Ie() {}
  
  virtual BYTE GetLengthOfData() { return 0; }
  
  BYTE GetValue() { return 0; }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(void * /*newData*/) 
  { PAssertAlways("IeNone cannot set data"); }
  
  int ReadData() { PAssertAlways("IeNone cannot read the internal data value"); return 0; }
  
 protected:
  virtual void WriteBinary(BYTE * /*data*/) {  }
};


class IAX2IeByte : public IAX2Ie
{
  PCLASSINFO(IAX2IeByte, IAX2Ie);
  
  IAX2IeByte(BYTE length, BYTE *srcData);     
  
  IAX2IeByte(BYTE newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeByte() : IAX2Ie() { }
  
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(BYTE newData) { dataValue = newData; validData = true; }
  
  BYTE ReadData() { return dataValue; }
  
 protected:
  virtual void WriteBinary(BYTE *data) { data[0] = dataValue; }
  
  BYTE dataValue;
};


class IAX2IeChar : public IAX2Ie
{
  PCLASSINFO(IAX2IeChar, IAX2Ie);
  
  IAX2IeChar(BYTE length, BYTE *srcData);     
  
  IAX2IeChar(char newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeChar() : IAX2Ie() { }
  
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(char newData) { dataValue = newData; validData = true; }
  
  char ReadData() { return dataValue; }
  
 protected:
  virtual void WriteBinary(BYTE *data) { data[0] = dataValue; }
  
  char dataValue;
};


class IAX2IeShort : public IAX2Ie
{
  PCLASSINFO(IAX2IeShort, IAX2Ie);
  
  IAX2IeShort(BYTE length, BYTE *srcData);     
  
  IAX2IeShort(short newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeShort() : IAX2Ie() { }
  
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(short newData) { dataValue = newData; validData = true; }
  
  short ReadData() { return dataValue; }  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  short dataValue;
};

class IAX2IeInt : public IAX2Ie
{
  PCLASSINFO(IAX2IeInt, IAX2Ie);
  
  IAX2IeInt(BYTE length, BYTE *srcData);     
  
  IAX2IeInt(int  newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeInt() : IAX2Ie() { }
  
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(int newData) { dataValue = newData; validData = true; }
  
  int ReadData() { return dataValue; }
  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  int dataValue;
};

class IAX2IeUShort : public IAX2Ie
{
  PCLASSINFO(IAX2IeUShort, IAX2Ie);
  
  IAX2IeUShort(BYTE length, BYTE *srcData);     
  
  IAX2IeUShort(unsigned short newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeUShort() : IAX2Ie() {}
  
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(unsigned short newData) { dataValue = newData; validData = true; }
  
  unsigned short ReadData() { return dataValue; }         
 protected:
  virtual void WriteBinary(BYTE *data);
  
  unsigned short dataValue;
};

class IAX2IeUInt : public IAX2Ie
{
  PCLASSINFO(IAX2IeUInt, IAX2Ie);
  
  IAX2IeUInt(BYTE length, BYTE *srcData);     
  
  IAX2IeUInt() : IAX2Ie() {}
  
  IAX2IeUInt(unsigned int newValue) { SetData(newValue); }
  
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(unsigned int &newData) { dataValue = newData; validData = true; }
  
  unsigned int ReadData() { return dataValue; }          
  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  unsigned int dataValue;
};


class IAX2IeString : public IAX2Ie
{
  PCLASSINFO(IAX2IeString, IAX2Ie);
  
 public:
  IAX2IeString(BYTE length, BYTE *srcData);     
  
  IAX2IeString(const PString & newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeString(const char * newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeString() : IAX2Ie() {}
  
  virtual BYTE GetLengthOfData();
  
  void PrintOn(ostream & str) const;
  
  void SetData(const PString & newData);
  
  void SetData(const char * newData);
  
  PString ReadData() { return dataValue; }          
  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  PString dataValue;
};


class IAX2IeBinary : public IAX2Ie
{
  PCLASSINFO(IAX2IeBinary, IAX2Ie);
  
 public:
  IAX2IeBinary(BYTE length, BYTE *srcData);     
  
  IAX2IeBinary(PBYTEArray newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeBinary() : IAX2Ie() {}
  
  virtual BYTE GetLengthOfData() { return (BYTE)dataValue.GetSize(); }
  
  virtual void PrintOn(ostream & str) const;
  
  void SetData(const PBYTEArray & newData);

  void GetData(PBYTEArray & answer);

  void CopyData(IAX2IeBinary *src);
  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  PBYTEArray dataValue;
};



class IAX2IeDateAndTime : public IAX2Ie
{
  PCLASSINFO(IAX2IeDateAndTime, IAX2Ie);
  
 public:
  IAX2IeDateAndTime(BYTE length, BYTE *srcData);     
  
  IAX2IeDateAndTime(const PTime & newValue) : IAX2Ie() { SetData(newValue); }
  
  IAX2IeDateAndTime() : IAX2Ie() {}
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetLengthOfData() { return 4; }
  
  void SetData(const PTime & newData) 
  { dataValue = newData; validData = true; }
  
  PTime ReadData() { return dataValue; }
 protected:
  virtual void WriteBinary(BYTE *data);
  
  PTime dataValue;
};

class IAX2IeBlockOfData : public IAX2Ie
{
  PCLASSINFO(IAX2IeBlockOfData, IAX2Ie);
  
 public:
  IAX2IeBlockOfData(BYTE length, BYTE *srcData);     
  
  IAX2IeBlockOfData(const PBYTEArray & newData) : IAX2Ie() { SetData(newData); }
  
  IAX2IeBlockOfData() : IAX2Ie() {}
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetLengthOfData() { return (BYTE)dataValue.GetSize(); }
  
  void SetData(const PBYTEArray & newData) 
     { dataValue = newData; validData = true; }
  
  PBYTEArray ReadData() { return dataValue; }
  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  PBYTEArray dataValue;
};

class IAX2IeSockaddrIn : public IAX2Ie
{
  PCLASSINFO(IAX2IeSockaddrIn, IAX2Ie);
  
 public:
  IAX2IeSockaddrIn(BYTE length, BYTE *srcData);     
  
  IAX2IeSockaddrIn(const PIPSocket::Address & addr, PINDEX port) : IAX2Ie() 
    { SetData(addr, port); }
  
  IAX2IeSockaddrIn() : IAX2Ie() {}
  
  ~IAX2IeSockaddrIn() { } ;
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetLengthOfData() { return sizeof(struct sockaddr_in); }
    
  void SetData(const PIPSocket::Address & newAddr, PINDEX newPort) 
    { dataValue = newAddr; portNumber = newPort; validData = true; }
  
  PIPSocket::Address ReadData() { return dataValue; }
  
 protected:
  virtual void WriteBinary(BYTE *data);
  
  PIPSocket::Address dataValue;
  
  PINDEX               portNumber;
};


class IAX2IeCalledNumber : public IAX2IeString
{
  PCLASSINFO(IAX2IeCalledNumber, IAX2IeString);
 public:
  IAX2IeCalledNumber(BYTE length, BYTE *srcData) 
    : IAX2IeString(length, srcData) {};
  
  IAX2IeCalledNumber(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_calledNumber; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.calledNumber = dataValue; }
 protected:
};

class IAX2IeCallingNumber : public IAX2IeString
{
  PCLASSINFO(IAX2IeCallingNumber, IAX2IeString);
 public:
  IAX2IeCallingNumber(BYTE length, BYTE *srcData) 
     : IAX2IeString(length, srcData) { };
  
  IAX2IeCallingNumber(const PString & newValue)  { SetData(newValue); } 
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callingNumber; }
  
  virtual void StoreDataIn(IAX2IeData &res) 
  { res.callingNumber = dataValue; }     
 protected:
};


class IAX2IeCallingAni : public IAX2IeString
{
  PCLASSINFO(IAX2IeCallingAni, IAX2IeString);
 public:
  IAX2IeCallingAni(BYTE length, BYTE *srcData) 
    : IAX2IeString(length, srcData) { };
  
  IAX2IeCallingAni(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callingAni; }
  
  virtual void StoreDataIn(IAX2IeData &res) 
     { res.callingAni = dataValue; }     
 protected:
};


class IAX2IeCallingName : public IAX2IeString
{
  PCLASSINFO(IAX2IeCallingName, IAX2IeString);
 public:
  IAX2IeCallingName(BYTE length, BYTE *srcData) 
    : IAX2IeString(length, srcData) { };
  
  IAX2IeCallingName(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callingName; }
  
  virtual void StoreDataIn(IAX2IeData &res) 
  { res.callingName = dataValue; }     
 protected:
};


class IAX2IeCalledContext : public IAX2IeString
{
  PCLASSINFO(IAX2IeCalledContext, IAX2IeString);
 public:
  IAX2IeCalledContext(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeCalledContext(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_calledContext; }
  
  virtual void StoreDataIn(IAX2IeData &res) 
  { res.calledContext = dataValue; }     
 protected:
};


class IAX2IeUserName : public IAX2IeString
{
  PCLASSINFO(IAX2IeUserName, IAX2IeString);
 public:
  IAX2IeUserName(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeUserName(const PString & newValue)  { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_userName; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.userName = dataValue; }     
 protected:
};


class IAX2IePassword : public IAX2IeString
{
  PCLASSINFO(IAX2IePassword, IAX2IeString);
 public:
  IAX2IePassword(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IePassword(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_password; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.password = dataValue; }     
 protected:
};


class IAX2IeCapability : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeCapability, IAX2IeUInt);
 public:
  IAX2IeCapability(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  IAX2IeCapability(unsigned int newValue) : IAX2IeUInt(newValue) { }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_capability; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.capability = dataValue; }     
 protected:
};


class IAX2IeFormat : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeFormat, IAX2IeUInt);
 public:
  IAX2IeFormat(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  IAX2IeFormat(unsigned int newValue) : IAX2IeUInt(newValue) { }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_format; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.format = dataValue; }     
 protected:
};


class IAX2IeLanguage : public IAX2IeString
{
  PCLASSINFO(IAX2IeLanguage, IAX2IeString);
 public:
  IAX2IeLanguage(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeLanguage(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_language; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.language = dataValue; }     
 protected:
};


class IAX2IeVersion : public IAX2IeShort
{
  PCLASSINFO(IAX2IeVersion, IAX2IeShort);
 public:
  IAX2IeVersion(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  IAX2IeVersion() { dataValue = 2; validData = true; }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_version; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.version = dataValue; }     
 protected:
};


class IAX2IeAdsicpe : public IAX2IeShort
{
  PCLASSINFO(IAX2IeAdsicpe, IAX2IeShort);
 public:
  IAX2IeAdsicpe(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_adsicpe; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.adsicpe = dataValue; }     
 protected:
};


class IAX2IeDnid : public IAX2IeString
{
  PCLASSINFO(IAX2IeDnid, IAX2IeString);
 public:
  IAX2IeDnid(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeDnid(const PString & newValue)  { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_dnid; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.dnid = dataValue; }     
 protected:
};


class IAX2IeAuthMethods : public IAX2IeShort
{
  PCLASSINFO(IAX2IeAuthMethods, IAX2IeShort);
 public:
  IAX2IeAuthMethods(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  IAX2IeAuthMethods(short newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_authMethods; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.authMethods = dataValue; }     
  
  static PBoolean IsRsaAuthentication(short testValue) { return InternalIsRsa(testValue); }
  
  static PBoolean IsMd5Authentication(short testValue) { return InternalIsMd5(testValue); }
  
  static PBoolean IsPlainTextAuthentication(short testValue) { return InternalIsPlainText(testValue); }     
  
  PBoolean IsRsaAuthentication() { if (IsValid()) return InternalIsRsa(dataValue); else return false; }
  
  PBoolean IsMd5Authentication() { if (IsValid()) return InternalIsMd5(dataValue); else return false; }
  
  PBoolean IsPlainTextAuthentication() { if (IsValid()) return InternalIsPlainText(dataValue); else return false; }
  
 protected:
  
  static PBoolean InternalIsRsa(short testValue) { return testValue  & 0x04; }
  
  static PBoolean InternalIsMd5(short testValue) { return testValue  & 0x02; }
  
  static PBoolean InternalIsPlainText(short testValue) { return testValue  & 0x01; }
};


class IAX2IeChallenge : public IAX2IeString
{
  PCLASSINFO(IAX2IeChallenge, IAX2IeString);
 public:
  IAX2IeChallenge(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeChallenge(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_challenge; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.challenge = dataValue; }     
 protected:
};


class IAX2IeMd5Result : public IAX2IeString
{
  PCLASSINFO(IAX2IeMd5Result, IAX2IeString);
 public:
  IAX2IeMd5Result(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeMd5Result(const PString & newValue) { SetData(newValue); }
  
  IAX2IeMd5Result(const PString & challenge, const PString & password);
  
  IAX2IeMd5Result(IAX2Encryption & encryption);
  
  void InitializeChallengePassword(const PString & newChallenge, const PString & newPassword);

  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_md5Result; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.md5Result = dataValue; }     

  PBYTEArray & GetDataBlock() { return dataBlock; }

 protected:

  PBYTEArray dataBlock;
};


class IAX2IeRsaResult : public IAX2IeString
{
  PCLASSINFO(IAX2IeRsaResult, IAX2IeString);
 public:
  IAX2IeRsaResult(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeRsaResult(const PString & newValue) { SetData(newValue); }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_rsaResult; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.rsaResult = dataValue; }
 protected:
};


class IAX2IeApparentAddr : public IAX2IeSockaddrIn
{
  PCLASSINFO(IAX2IeApparentAddr, IAX2IeSockaddrIn);
 public:
  IAX2IeApparentAddr(BYTE length, BYTE *srcData) : IAX2IeSockaddrIn(length, srcData) { };
  
  ~IAX2IeApparentAddr() { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_apparentAddr; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.apparentAddr = dataValue; }     
 protected:
};


class IAX2IeRefresh : public IAX2IeShort
{
  PCLASSINFO(IAX2IeRefresh, IAX2IeShort);
 public:
  IAX2IeRefresh(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  IAX2IeRefresh(short refreshTime) : IAX2IeShort(refreshTime) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_refresh; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.refresh = dataValue; }     
 protected:
};


class IAX2IeDpStatus : public IAX2IeShort
{
  PCLASSINFO(IAX2IeDpStatus, IAX2IeShort);
 public:
  IAX2IeDpStatus(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_dpStatus; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.dpStatus = dataValue; }     
 protected:
};


class IAX2IeCallNo : public IAX2IeShort
{
  PCLASSINFO(IAX2IeCallNo, IAX2IeShort);
 public:
  IAX2IeCallNo(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callNo; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.callNo = dataValue; }     
 protected:
};


class IAX2IeCause : public IAX2IeString
{
  PCLASSINFO(IAX2IeCause, IAX2IeString);
 public:
  IAX2IeCause(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  IAX2IeCause(const PString & newValue) : IAX2IeString(newValue) { }
  
  IAX2IeCause(const char *newValue) : IAX2IeString(newValue) { }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_cause; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.cause = dataValue; }     
 protected:
};


class IAX2IeIaxUnknown : public IAX2IeByte
{
  PCLASSINFO(IAX2IeIaxUnknown, IAX2IeByte);
 public:
  IAX2IeIaxUnknown(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
  
  IAX2IeIaxUnknown(BYTE newValue) : IAX2IeByte(newValue) { }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_iaxUnknown; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.iaxUnknown = dataValue; }     
 protected:
};


class IAX2IeMsgCount : public IAX2IeShort
{
  PCLASSINFO(IAX2IeMsgCount, IAX2IeShort);
 public:
  IAX2IeMsgCount(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_msgCount; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.msgCount = dataValue; }     
 protected:
};


class IAX2IeAutoAnswer : public IAX2IeNone
{
  PCLASSINFO(IAX2IeAutoAnswer, IAX2IeNone);
 public:
  IAX2IeAutoAnswer(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_autoAnswer; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.autoAnswer = true;; }     
 protected:
};


class IAX2IeMusicOnHold : public IAX2IeNone
{
  PCLASSINFO(IAX2IeMusicOnHold, IAX2IeNone);
 public:
  IAX2IeMusicOnHold(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };
  
  IAX2IeMusicOnHold() : IAX2IeNone() { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_musicOnHold; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.musicOnHold = true; }     
 protected:
};


class IAX2IeTransferId : public IAX2IeInt
{
  PCLASSINFO(IAX2IeTransferId, IAX2IeInt);
 public:
  IAX2IeTransferId(BYTE length, BYTE *srcData) : IAX2IeInt(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_transferId; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.transferId = dataValue; }     
 protected:
};


class IAX2IeRdnis : public IAX2IeString
{
  PCLASSINFO(IAX2IeRdnis, IAX2IeString);
 public:
  IAX2IeRdnis(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_rdnis; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.rdnis = dataValue; }     
 protected:
};


class IAX2IeProvisioning : public IAX2IeBlockOfData
{
  PCLASSINFO(IAX2IeProvisioning, IAX2IeBlockOfData);
 public:
  IAX2IeProvisioning(BYTE length, BYTE *srcData) : IAX2IeBlockOfData   (length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_provisioning; }
  
  virtual void StoreDataIn(IAX2IeData &/*res*/) {  }     
 protected:
};


class IAX2IeAesProvisioning : public IAX2IeNone
{
  PCLASSINFO(IAX2IeAesProvisioning, IAX2IeNone);
 public:
  IAX2IeAesProvisioning(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_aesProvisioning; }
  
  virtual void StoreDataIn(IAX2IeData &/*res*/) {  }     
 protected:
};


class IAX2IeDateTime : public IAX2IeDateAndTime
{
  PCLASSINFO(IAX2IeDateTime, IAX2IeDateAndTime);
 public:
  IAX2IeDateTime(BYTE length, BYTE *srcData) : IAX2IeDateAndTime(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_dateTime; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.dateTime = dataValue; }     
 protected:
};


class IAX2IeDeviceType : public IAX2IeString
{
  PCLASSINFO(IAX2IeDeviceType, IAX2IeString);
 public:
  IAX2IeDeviceType(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_deviceType; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.deviceType = dataValue; }     
 protected:
};


class IAX2IeServiceIdent : public IAX2IeString
{
  PCLASSINFO(IAX2IeServiceIdent, IAX2IeString);
 public:
  IAX2IeServiceIdent(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_serviceIdent; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.serviceIdent = dataValue; }     
 protected:
};


class IAX2IeFirmwareVer : public IAX2IeShort
{
  PCLASSINFO(IAX2IeFirmwareVer, IAX2IeShort);
 public:
  IAX2IeFirmwareVer(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_firmwareVer; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.firmwareVer = dataValue; }     
 protected:
};


class IAX2IeFwBlockDesc : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeFwBlockDesc, IAX2IeUInt);
 public:
  IAX2IeFwBlockDesc(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  IAX2IeFwBlockDesc(unsigned int newValue) : IAX2IeUInt(newValue) { }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_fwBlockDesc; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.fwBlockDesc = dataValue; }     
 protected:
};


class IAX2IeFwBlockData : public IAX2IeBlockOfData
{
  PCLASSINFO(IAX2IeFwBlockData, IAX2IeBlockOfData);
 public:
  IAX2IeFwBlockData(BYTE length, BYTE *srcData) : IAX2IeBlockOfData(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_fwBlockData; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.fwBlockData = dataValue; }     
 protected:
};


class IAX2IeProvVer : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeProvVer, IAX2IeUInt);
 public:
  IAX2IeProvVer(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  IAX2IeProvVer(unsigned int newValue) : IAX2IeUInt(newValue) { }
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_provVer; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.provVer = dataValue; }     
 protected:
};


class IAX2IeCallingPres : public IAX2IeByte
{
  PCLASSINFO(IAX2IeCallingPres, IAX2IeByte);
 public:
  IAX2IeCallingPres(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callingPres; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.callingPres = dataValue; }     
 protected:
};


class IAX2IeCallingTon : public IAX2IeByte
{
  PCLASSINFO(IAX2IeCallingTon, IAX2IeByte);
 public:
  IAX2IeCallingTon(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callingTon; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.callingTon = dataValue; }     
 protected:
};


class IAX2IeCallingTns : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeCallingTns, IAX2IeUShort);
 public:
  IAX2IeCallingTns(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callingTns; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.callingTns = dataValue; }     
 protected:
};


class IAX2IeSamplingRate : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeSamplingRate, IAX2IeUShort);
 public:
  IAX2IeSamplingRate(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_samplingRate; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.samplingRate = dataValue; }     
 protected:
};


class IAX2IeEncryption : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeEncryption, IAX2IeUShort);
 public:
  enum IAX2IeEncryptionMethod {
    encryptAes128 = 1    
  };

  IAX2IeEncryption(IAX2IeEncryptionMethod method = encryptAes128);

  IAX2IeEncryption(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_encryption; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.encryptionMethods = dataValue; }
 protected:
};


class IAX2IeEncKey : public IAX2IeString
{
  PCLASSINFO(IAX2IeEncKey, IAX2IeString);
 public:
  IAX2IeEncKey(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_encKey; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.encKey = dataValue; }     
 protected:
};


class IAX2IeCodecPrefs : public IAX2IeByte
{
  PCLASSINFO(IAX2IeCodecPrefs, IAX2IeByte);
 public:
  IAX2IeCodecPrefs(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_codecPrefs; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.codecPrefs = dataValue; }     
 protected:
};


class IAX2IeReceivedJitter : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedJitter, IAX2IeUInt);
 public:
  IAX2IeReceivedJitter(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_recJitter; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedJitter = dataValue; }     
 protected:
};


class IAX2IeReceivedLoss : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedLoss, IAX2IeUInt);
 public:
  IAX2IeReceivedLoss(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_recLoss; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedLoss = dataValue; }     
 protected:
};


class IAX2IeReceivedFrames : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedFrames, IAX2IeUInt);
 public:
  IAX2IeReceivedFrames(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_recPackets; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedPackets = dataValue; }     
 protected:
};


class IAX2IeReceivedDelay : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeReceivedDelay, IAX2IeUShort);
 public:
  IAX2IeReceivedDelay(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_recDelay; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedDelay = dataValue; }     
 protected:
};


class IAX2IeDroppedFrames : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeDroppedFrames, IAX2IeUInt);
 public:
  IAX2IeDroppedFrames(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_recDropped; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedDropped = dataValue; }     
 protected:
};


class IAX2IeReceivedOoo : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedOoo, IAX2IeUInt);
 public:
  IAX2IeReceivedOoo(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
  
  virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_recOoo; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedOoo = dataValue; }     
 protected:
};


class IAX2IeCallToken : public IAX2IeBinary
{
  PCLASSINFO(IAX2IeCallToken, IAX2IeBinary);
 public:
  IAX2IeCallToken(BYTE length, BYTE *srcData) 
    : IAX2IeBinary(length, srcData) { };
    
   IAX2IeCallToken() : IAX2IeBinary(0, NULL) {};
     
     virtual void PrintOn(ostream & str) const;
  
  virtual BYTE GetKeyValue() const  { return ie_callToken; }
  
  virtual void StoreDataIn(IAX2IeData &res) { res.callToken = dataValue; }     

  static void InitialiseKey();

  void WriteKeySequence(PIPSocket::Address & remoteAddress);

  static PBoolean ValidKeySequence (IAX2IeCallToken & cf, 
                                    PIPSocket::Address & remote);

 protected:
  static PString ReportKeySequence(const PString & time, PIPSocket::Address & remote);

  enum {
    iKeyValue = 0x36, 
    oKeyValue = 0x5c, 
    blockSize = 64    
  };

  static PString secretKey;

  static BYTE iKeyPad[blockSize];

  static BYTE oKeyPad[blockSize];
};


PDECLARE_LIST (IAX2IeList, IAX2Ie *)
#ifdef DOC_PLUS_PLUS 

class IAX2IeList : public IAX2Ie *
{
#endif
 public:
  ~IAX2IeList();
  
  IAX2Ie *RemoveIeAt(PINDEX i);
  
  IAX2Ie *RemoveLastIe();
  
  void Initialise() {  DisallowDeleteObjects(); }
  
  void DeleteAt(PINDEX idex);
  
  PBoolean Empty() const { return GetSize() == 0; }
  
  PBoolean IsEmpty() const { return GetSize() == 0; }
  
  void AppendIe(IAX2Ie *newMember) { Append(newMember);}
  
  int GetBinaryDataSize() const;
  
  IAX2Ie * GetIeAt(int i) const;
  
 protected:
  
};


#endif // OPAL_IAX2

#endif // OPAL_IAX2_IES_H

/* The comment below is magic for those who use emacs to edit this file. 
 * With the comment below, the tab key does auto indent to 2 spaces.     
 *
 * Local Variables:
 * mode:c
 * c-basic-offset:2
 * End:
 */

---