xref: /dports/net/opal/opal-3.10.10/include/iax2/ies.h

/*
 *
 * 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;

/**Ie class is for handling information elements*/
class IAX2Ie : public PObject
{
  PCLASSINFO(IAX2Ie, PObject);
 public:
  /** Each of the 45 possible Information Element types */
  enum IAX2IeTypeCode {
    ie_calledNumber      = 1,     /*!< Number or extension that is being being called  (string)    */
    ie_callingNumber     = 2,     /*!< The number of the node initating the call r (string)   */
    ie_callingAni        = 3,     /*!< The ANI (calling number) to use for billing   (string)   */
    ie_callingName       = 4,     /*!< The callers name (string)    */
    ie_calledContext     = 5,     /*!< The context we are calling to (string) */
    ie_userName          = 6,     /*!< UserName (peer or user) to use in the  authentication process (string)    */
    ie_password          = 7,     /*!< Password - which is used in the authentication process (string)    */
    ie_capability        = 8,     /*!< Bitmask of the codecs sending end supports or senders capability  (unsigned int)    */
    ie_format            = 9,     /*!< Bitmask of the desired codec  (unsigned int)    */
    ie_language          = 10,    /*!< Sending ends preferred language string)    */
    ie_version           = 11,    /*!< Sending ends protocol version - typically 2.  (short)    */
    ie_adsicpe           = 12,    /*!< CPE ADSI capability (short)    */
    ie_dnid              = 13,    /*!< Originally dialed DNID (string)    */
    ie_authMethods       = 14,    /*!< Bitmask of the available Authentication method(s)  (short)    */
    ie_challenge         = 15,    /*!< The challenge data used in  MD5/RSA authentication (string)    */
    ie_md5Result         = 16,    /*!< MD5 challenge (authentication process) result (string)    */
    ie_rsaResult         = 17,    /*!< RSA challenge (authentication process) result (string)    */
    ie_apparentAddr      = 18,    /*!< The peer's apparent address. (struct sockaddr_in)    */
    ie_refresh           = 19,    /*!< The frequency of on with to refresh registration, in units of seconds  (short)    */
    ie_dpStatus          = 20,    /*!< The dialplan status (short)    */
    ie_callNo            = 21,    /*!< Call number of the  peer  (short)    */
    ie_cause             = 22,    /*!< Description of why hangup or authentication or other failure happened (string)    */
    ie_iaxUnknown        = 23,    /*!< An IAX command that is unknown (byte)    */
    ie_msgCount          = 24,    /*!< A report on the number of  messages waiting (short)    */
    ie_autoAnswer        = 25,    /*!< auto-answering is requested (no type required, as this is a request) */
    ie_musicOnHold       = 26,    /*!< Demand for music on hold combined with  QUELCH (string or none)    */
    ie_transferId        = 27,    /*!< Identifier for a Transfer Request (int)    */
    ie_rdnis             = 28,    /*!< DNIS of the referring agent (string)    */
    ie_provisioning      = 29,    /*!< Info to be used for provisioning   (binary data)  */
    ie_aesProvisioning   = 30,    /*!< Info for provisioning AES      (binary data) */
    ie_dateTime          = 31,    /*!< Date and Time  (which is stored in binary format defined in IAX2IeDateTime)    */
    ie_deviceType        = 32,    /*!< The type of device  (string)    */
    ie_serviceIdent      = 33,    /*!< The Identifier for service (string)   */
    ie_firmwareVer       = 34,    /*!< The version of firmware    (unsigned 32 bit number)    */
    ie_fwBlockDesc       = 35,    /*!< The description for a block of firmware (unsigned 32 bit number ) */
    ie_fwBlockData       = 36,    /*!< Binary data for a block of fw   () */
    ie_provVer           = 37,    /*!< The version of provisiong     (unsigned 32 bit number)    */
    ie_callingPres       = 38,    /*!< Presentation of calling (unsigned 8 bit) */
    ie_callingTon        = 39,    /*!< Type of number calling (unsigned 8 bit)   */
    ie_callingTns        = 40,    /*!< Transit Network Select for calling (unsigned 16 bit)  */
    ie_samplingRate      = 41,    /*!< Bitmask of supported Rate of sampling . Sampling defaults to 8000 hz, (unsigned 16)    */
    ie_causeCode         = 42,    /*!< Code value which describes why the registration failed, or call hungup etc (unsigned 8 bit) */
    ie_encryption        = 43,    /*!< The method for encrption the remote code wants to use (U16)    */
    ie_encKey            = 44,    /*!< the Key for ncryption (raw binary data)    */
    ie_codecPrefs        = 45,    /*!< The codec we would prefer to use (unsigned 8 bit)    */
    ie_recJitter         = 46,    /*!< From rfc 1889, the received jitter (unsigned 32 bit number) */
    ie_recLoss           = 47,    /*!< The received loss rate, where the high byte is the loss packt, low 24 bits loss count, from rfc1889 (unsigned 32 bit)*/
    ie_recPackets        = 48,    /*!< Recevied number of frames (total frames received) (unsigned 32 bit) */
    ie_recDelay          = 49,    /*!< Received frame largest playout delay (in ms) (unsigned 16 bit)*/
    ie_recDropped        = 50,    /*!< The number of dropped received frames by the jitter buf, so it is a measure of the number of late frames (unsigned 32 bit) */
    ie_recOoo            = 51,    /*!< The number of received frames which were Out Of Order (unsigned 32 number) */
    ie_variable          = 52,    /*!< do remote variables                                                            */
    ie_ospToken          = 53,    /*!< OSP token                                                                      */
    ie_callToken         = 54,    /*!< For security - do Call number tests                                            */
    ie_capability2       = 55,    /*!< Do the Actual codec capability - u8 version + integer array                    */
    ie_format2           = 56,    /*!< Desired codec format - u8 version + integer array                              */
    ie_countEntries              /*!< Report on how many different ie types there are                                */
  };

  /**@name construction/destruction*/
  //@{

  /**Constructor*/
  IAX2Ie();

  /**Destructor*/
  virtual ~IAX2Ie() { };
  //@{

  /**@name Worker methods*/
  //@{
  /** Given an arbitrary type code, build & initialise the IAX2Ie descendant class */
  static IAX2Ie *BuildInformationElement(BYTE _typeCode, BYTE length, BYTE *srcData);

  /** returns true if contains an initialised    information element */
  virtual PBoolean IsValid() { return validData; }

  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return 0; }

  /**return the number of bytes to hold this Information Element when stored in a packet*/
  int GetBinarySize() { return 2 + GetLengthOfData(); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /** Get the enum value for this information element class */
  virtual BYTE GetKeyValue() const  { return 255; }

  /**Take the supplied data and copy contents into this IE */
  void SetData(int &/*newData*/) { PAssertAlways("Ie class cannnot set data value"); };

  /**Read the value of the stored data for this class */
  int ReadData() { PAssertAlways("Ie class cannot read the internal data value"); return 0; };

  /** Take the data from this IAX2Ie and copy into the memory region.
      When finished, increment the writeIndex appropriately. */
  void WriteBinary(void *data, PINDEX & writeIndex);

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData structure.
      This is done on processing an incoming frame which contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &/*res*/) { PAssertAlways(PUnimplementedFunction); }
  //@}

 protected:
  /** Take the data value for this particular IAX2Ie and copy into the memory region.*/
  virtual void WriteBinary(BYTE * /*data*/) { PAssertAlways(PUnimplementedFunction); }

  /**A flag indicating if the data was read from the supplied bytes
     correctly, or if this structure is yet to be initialised */
  PBoolean   validData;
};

/////////////////////////////////////////////////////////////////////////////
/**An Information Element that identifies an invalid code in the processed binary data.*/
class IAX2IeInvalidElement : public IAX2Ie
{
  PCLASSINFO(IAX2IeInvalidElement, IAX2Ie);
 public:
  IAX2IeInvalidElement() : IAX2Ie() {};

  /**Access function to get the length of data, which is used when
     writing to network packet*/
  virtual BYTE GetlengthOfData() { return 0; }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const
    { str << "Invlalid Information Element" << endl; }
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.  For an IAX2IeInvalidElement, there is no work
      done, as the data is invalid. */
  virtual void WriteBinary(BYTE * /*data*/) {  }
};
/////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains no data. */
class IAX2IeNone : public IAX2Ie
{
  PCLASSINFO(IAX2IeNone, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeNone(BYTE length, BYTE *srcData);

  /**Constructor to an invalid and empty result*/
  IAX2IeNone() : IAX2Ie() {}
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return 0; }

  /**Report the value stored in this class */
  BYTE GetValue() { return 0; }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(void * /*newData*/)
  { PAssertAlways("IeNone cannot set data"); }

  /**Read the value of the stored data for this class */
  int ReadData() { PAssertAlways("IeNone cannot read the internal data value"); return 0; }

  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the memory region.
      For this IAX2Ie (IAX2IeNone) there is no work to do as there is no data. */
  virtual void WriteBinary(BYTE * /*data*/) {  }
};

/////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains one byte of data*/
class IAX2IeByte : public IAX2Ie
{
  PCLASSINFO(IAX2IeByte, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeByte(BYTE length, BYTE *srcData);

  /**Constructor to a specific value */
  IAX2IeByte(BYTE newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeByte() : IAX2Ie() { }
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(BYTE newData) { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  BYTE ReadData() { return dataValue; }

  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data) { data[0] = dataValue; }

  /**The actual data stored in a IAX2IeByte class */
  BYTE dataValue;
};

/////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains one character of data*/
class IAX2IeChar : public IAX2Ie
{
  PCLASSINFO(IAX2IeChar, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeChar(BYTE length, BYTE *srcData);

  /**Construct to an initialised value */
  IAX2IeChar(char newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeChar() : IAX2Ie() { }
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(char newData) { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  char ReadData() { return dataValue; }

  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data) { data[0] = dataValue; }

  /**The actual data stored in a IAX2IeChar class */
  char dataValue;
};

/////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains one short (signed 16 bits) of data*/
class IAX2IeShort : public IAX2Ie
{
  PCLASSINFO(IAX2IeShort, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeShort(BYTE length, BYTE *srcData);

  /**Construct to an initialied value */
  IAX2IeShort(short newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeShort() : IAX2Ie() { }
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(short newData) { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  short ReadData() { return dataValue; }
  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeShort class */
  short dataValue;
};
/////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains one integer (signed 16 bits) of data*/
class IAX2IeInt : public IAX2Ie
{
  PCLASSINFO(IAX2IeInt, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeInt(BYTE length, BYTE *srcData);

  /**Construct to an initialised value */
  IAX2IeInt(int  newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeInt() : IAX2Ie() { }
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(int newData) { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  int ReadData() { return dataValue; }

  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeInt class */
  int dataValue;
};
////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains an unsigned short (16 bits) of data*/
class IAX2IeUShort : public IAX2Ie
{
  PCLASSINFO(IAX2IeUShort, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeUShort(BYTE length, BYTE *srcData);

  /**Construct to an initialised value */
  IAX2IeUShort(unsigned short newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeUShort() : IAX2Ie() {}
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(unsigned short newData) { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  unsigned short ReadData() { return dataValue; }
  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeUShort class */
  unsigned short dataValue;
};
////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains an unsigned int (32 bits) of data*/
class IAX2IeUInt : public IAX2Ie
{
  PCLASSINFO(IAX2IeUInt, IAX2Ie);
  /**@name construction/destruction*/
  //@{

  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeUInt(BYTE length, BYTE *srcData);

  /**Constructor to an invalid and empty result*/
  IAX2IeUInt() : IAX2Ie() {}

  /**Constructor to an initialised value, (Typically used prior to transmission)*/
  IAX2IeUInt(unsigned int newValue) { SetData(newValue); }
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(dataValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(unsigned int &newData) { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  unsigned int ReadData() { return dataValue; }
  //@}

 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeUInt class */
  unsigned int dataValue;
};

////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains an array of characters. */
class IAX2IeString : public IAX2Ie
{
  PCLASSINFO(IAX2IeString, IAX2Ie);
  /**@name construction/destruction*/
  //@{

 public:
  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeString(BYTE length, BYTE *srcData);

  /**Construct to an initialised value */
  IAX2IeString(const PString & newValue) : IAX2Ie() { SetData(newValue); }

  /**Construct to an initialised value */
  IAX2IeString(const char * newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeString() : IAX2Ie() {}
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData();

  /**print this class (nicely) to the designated stream*/
  void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(const PString & newData);

  /**Take the supplied data and copy contents into this IE */
  void SetData(const char * newData);

  /**Report the value of the stored data for this class */
  PString ReadData() { return dataValue; }
  //@}

 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeString class */
  PString dataValue;
};

////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains numbers which are in the range
   of 0..255 It is valid to have zero elements in this field. */
class IAX2IeBinary : public IAX2Ie
{
  PCLASSINFO(IAX2IeBinary, IAX2Ie);
  /**@name construction/destruction*/
  //@{

 public:
  /**Constructor - read data from source array.

  If the length is zero, the value of srcData is ignored, and an empty
  array is created. */
  IAX2IeBinary(BYTE length, BYTE *srcData);

  /**Construct to an initialised value */
  IAX2IeBinary(PBYTEArray newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeBinary() : IAX2Ie() {}
  //@}

  /**@name Worker methods*/
  //@{
  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return (BYTE)dataValue.GetSize(); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Take the supplied data and copy contents into this IE */
  void SetData(const PBYTEArray & newData);

  /**Take the internal data and copy it to the parameter */
  void GetData(PBYTEArray & answer);

  /**Copy the data from the supplied IAX2IeBinary and put it into this
     instance */
  void CopyData(IAX2IeBinary *src);
  //@}

 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeBinary class */
  PBYTEArray dataValue;
};


////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains the date and time, from a 32 bit long representation*/
class IAX2IeDateAndTime : public IAX2Ie
{
  PCLASSINFO(IAX2IeDateAndTime, IAX2Ie);
  /**@name construction/destruction*/
  //@{

 public:
  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeDateAndTime(BYTE length, BYTE *srcData);

  /**Construct to an initialized value */
  IAX2IeDateAndTime(const PTime & newValue) : IAX2Ie() { SetData(newValue); }

  /**Constructor to an invalid and empty result*/
  IAX2IeDateAndTime() : IAX2Ie() {}
  //@}

  /**@name Worker methods*/
  //@{
  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return 4; }

  /**Take the supplied data and copy contents into this IE */
  void SetData(const PTime & newData)
  { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  PTime ReadData() { return dataValue; }
  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeDateAndTime class */
  PTime dataValue;
};
////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains an array of BYTES (with possible nulls in middle) */
class IAX2IeBlockOfData : public IAX2Ie
{
  PCLASSINFO(IAX2IeBlockOfData, IAX2Ie);
  /**@name construction/destruction*/
  //@{

 public:
  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeBlockOfData(BYTE length, BYTE *srcData);

  /**Construct to an initialized value */
  IAX2IeBlockOfData(const PBYTEArray & newData) : IAX2Ie() { SetData(newData); }

  /**Constructor to an invalid and empty result*/
  IAX2IeBlockOfData() : IAX2Ie() {}
  //@}

  /**@name Worker methods*/
  //@{
  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return (BYTE)dataValue.GetSize(); }

  /**Take the supplied data and copy contents into this IE */
  void SetData(const PBYTEArray & newData)
     { dataValue = newData; validData = true; }

  /**Report the value of the stored data for this class */
  PBYTEArray ReadData() { return dataValue; }

  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual data stored in a IAX2IeBlockOfData class */
  PBYTEArray dataValue;
};
////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains an Ip address and port */
class IAX2IeSockaddrIn : public IAX2Ie
{
  PCLASSINFO(IAX2IeSockaddrIn, IAX2Ie);
  /**@name construction/destruction*/
  //@{

 public:
  /**Constructor - read data from source array.

  Contents are valid if source array is valid. */
  IAX2IeSockaddrIn(BYTE length, BYTE *srcData);

  /**Construct to an initialized value */
  IAX2IeSockaddrIn(const PIPSocket::Address & addr, PINDEX port) : IAX2Ie()
    { SetData(addr, port); }

  /**Constructor to an invalid and empty result*/
  IAX2IeSockaddrIn() : IAX2Ie() {}

  /**Destructor*/
  ~IAX2IeSockaddrIn() { } ;
  //@}

  /**@name Worker methods*/
  //@{
  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**return the number of bytes to hold this data element */
  virtual BYTE GetLengthOfData() { return sizeof(struct sockaddr_in); }

  /**Take the supplied data and copy contents into this IE */
  void SetData(const PIPSocket::Address & newAddr, PINDEX newPort)
    { dataValue = newAddr; portNumber = newPort; validData = true; }

  /**Report the value of the stored data for this class */
  PIPSocket::Address ReadData() { return dataValue; }

  //@}
 protected:
  /** Take the data value for this particular IAX2Ie and copy into the
      memory region.*/
  virtual void WriteBinary(BYTE *data);

  /**The actual ip address data stored in a IAX2IeSockaddrIn class */
  PIPSocket::Address dataValue;

  /**The actual port number data stored in a IAX2IeSockaddrIn class */
  PINDEX               portNumber;
};

////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains the number/extension being called.*/
class IAX2IeCalledNumber : public IAX2IeString
{
  PCLASSINFO(IAX2IeCalledNumber, IAX2IeString);
 public:
  /**Constructor from data read from the network.

  Contents are undefined if network data is bogus.*/
  IAX2IeCalledNumber(BYTE length, BYTE *srcData)
    : IAX2IeString(length, srcData) {};

  /**Initialise to the supplied string value */
  IAX2IeCalledNumber(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_calledNumber; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.calledNumber = dataValue; }
 protected:
};
////////////////////////////////////////////////////////////////////////////////
/**An Information Element that contains the Calling number (number
   trying to make call?)*/
class IAX2IeCallingNumber : public IAX2IeString
{
  PCLASSINFO(IAX2IeCallingNumber, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus. */
  IAX2IeCallingNumber(BYTE length, BYTE *srcData)
     : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeCallingNumber(const PString & newValue)  { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callingNumber; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res)
  { res.callingNumber = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the calling number ANI (for billing)*/
class IAX2IeCallingAni : public IAX2IeString
{
  PCLASSINFO(IAX2IeCallingAni, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus. */
  IAX2IeCallingAni(BYTE length, BYTE *srcData)
    : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeCallingAni(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callingAni; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res)
     { res.callingAni = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains name of the the person making the call*/
class IAX2IeCallingName : public IAX2IeString
{
  PCLASSINFO(IAX2IeCallingName, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCallingName(BYTE length, BYTE *srcData)
    : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeCallingName(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callingName; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res)
  { res.callingName = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the context for this number*/
class IAX2IeCalledContext : public IAX2IeString
{
  PCLASSINFO(IAX2IeCalledContext, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCalledContext(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeCalledContext(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_calledContext; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res)
  { res.calledContext = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the userName (peer or user) for authentication*/
class IAX2IeUserName : public IAX2IeString
{
  PCLASSINFO(IAX2IeUserName, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeUserName(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeUserName(const PString & newValue)  { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_userName; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.userName = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the password (for authentication)*/
class IAX2IePassword : public IAX2IeString
{
  PCLASSINFO(IAX2IePassword, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IePassword(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IePassword(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_password; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.password = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the actual codecs available*/
class IAX2IeCapability : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeCapability, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCapability(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeCapability(unsigned int newValue) : IAX2IeUInt(newValue) { }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_capability; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.capability = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the desired codec format*/
class IAX2IeFormat : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeFormat, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeFormat(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeFormat(unsigned int newValue) : IAX2IeUInt(newValue) { }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_format; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.format = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the desired language*/
class IAX2IeLanguage : public IAX2IeString
{
  PCLASSINFO(IAX2IeLanguage, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeLanguage(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeLanguage(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_language; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.language = dataValue; }
 protected:
};

//////////////////////////////////////////////////////////////////////
/**An Information Element that contains the protocol version*/
class IAX2IeVersion : public IAX2IeShort
{
  PCLASSINFO(IAX2IeVersion, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeVersion(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /**Construct to the one possible value - version 2 */
  IAX2IeVersion() { dataValue = 2; validData = true; }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_version; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.version = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the CPE ADSI capability*/
class IAX2IeAdsicpe : public IAX2IeShort
{
  PCLASSINFO(IAX2IeAdsicpe, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeAdsicpe(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_adsicpe; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.adsicpe = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains  the originally dialed DNID*/
class IAX2IeDnid : public IAX2IeString
{
  PCLASSINFO(IAX2IeDnid, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeDnid(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeDnid(const PString & newValue)  { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_dnid; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.dnid = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the authentication methods */
class IAX2IeAuthMethods : public IAX2IeShort
{
  PCLASSINFO(IAX2IeAuthMethods, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeAuthMethods(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /** Initialise to the supplied short value, which is usually done prior to transmission*/
  IAX2IeAuthMethods(short newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_authMethods; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.authMethods = dataValue; }

  /**Return true if the supplied value has the RSA key on*/
  static PBoolean IsRsaAuthentication(short testValue) { return InternalIsRsa(testValue); }

  /**Return true if the supplied value has the MD5 key on*/
  static PBoolean IsMd5Authentication(short testValue) { return InternalIsMd5(testValue); }

  /**Return true if the supplied value has the plain text  key on*/
  static PBoolean IsPlainTextAuthentication(short testValue) { return InternalIsPlainText(testValue); }

  /**Return true if the internal value has the RSA key on*/
  PBoolean IsRsaAuthentication() { if (IsValid()) return InternalIsRsa(dataValue); else return false; }

  /**Return true if the internal value has the MD5 key on*/
  PBoolean IsMd5Authentication() { if (IsValid()) return InternalIsMd5(dataValue); else return false; }

  /**Return true if the internal value has the plain text  key on*/
  PBoolean IsPlainTextAuthentication() { if (IsValid()) return InternalIsPlainText(dataValue); else return false; }

 protected:

  /**Return true if the supplied value has the RSA key on*/
  static PBoolean InternalIsRsa(short testValue) { return testValue  & 0x04; }

  /**Return true if the supplied value has the MD5 key on*/
  static PBoolean InternalIsMd5(short testValue) { return testValue  & 0x02; }

  /**Return true if the supplied value has the plain text  key on*/
  static PBoolean InternalIsPlainText(short testValue) { return testValue  & 0x01; }
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the challenge data for MD5/RSA*/
class IAX2IeChallenge : public IAX2IeString
{
  PCLASSINFO(IAX2IeChallenge, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeChallenge(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeChallenge(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_challenge; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.challenge = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the MD5 chaallenge result*/
class IAX2IeMd5Result : public IAX2IeString
{
  PCLASSINFO(IAX2IeMd5Result, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeMd5Result(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeMd5Result(const PString & newValue) { SetData(newValue); }

  /**Take the challenge and password, calculate the result, and store */
  IAX2IeMd5Result(const PString & challenge, const PString & password);

  /**Take the supplied Iax2Encrption arguement, calculate the result, and store */
  IAX2IeMd5Result(IAX2Encryption & encryption);

  /**Initialize the internal structurees */
  void InitializeChallengePassword(const PString & newChallenge, const PString & newPassword);

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_md5Result; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.md5Result = dataValue; }

  /**GetAccess to the stomach, which is the concatanation of the various
     components used to make a key */
  PBYTEArray & GetDataBlock() { return dataBlock; }

 protected:

  /**The contents of the stomach in a binary block */
  PBYTEArray dataBlock;
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the RSA challenge result*/
class IAX2IeRsaResult : public IAX2IeString
{
  PCLASSINFO(IAX2IeRsaResult, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeRsaResult(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Initialise to the supplied string value */
  IAX2IeRsaResult(const PString & newValue) { SetData(newValue); }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_rsaResult; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.rsaResult = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the apparent daddress of peer*/
class IAX2IeApparentAddr : public IAX2IeSockaddrIn
{
  PCLASSINFO(IAX2IeApparentAddr, IAX2IeSockaddrIn);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeApparentAddr(BYTE length, BYTE *srcData) : IAX2IeSockaddrIn(length, srcData) { };

  /**Desttructor, which does nothing */
  ~IAX2IeApparentAddr() { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_apparentAddr; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.apparentAddr = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the time when to refresh registration*/
class IAX2IeRefresh : public IAX2IeShort
{
  PCLASSINFO(IAX2IeRefresh, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeRefresh(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /** Constructor for an outgoing refresh information element */
  IAX2IeRefresh(short refreshTime) : IAX2IeShort(refreshTime) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_refresh; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.refresh = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the dial plan status*/
class IAX2IeDpStatus : public IAX2IeShort
{
  PCLASSINFO(IAX2IeDpStatus, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeDpStatus(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_dpStatus; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.dpStatus = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains  the call number of peer*/
class IAX2IeCallNo : public IAX2IeShort
{
  PCLASSINFO(IAX2IeCallNo, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCallNo(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callNo; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.callNo = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the cause*/
class IAX2IeCause : public IAX2IeString
{
  PCLASSINFO(IAX2IeCause, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCause(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeCause(const PString & newValue) : IAX2IeString(newValue) { }

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeCause(const char *newValue) : IAX2IeString(newValue) { }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_cause; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.cause = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains  an unknown IAX command*/
class IAX2IeIaxUnknown : public IAX2IeByte
{
  PCLASSINFO(IAX2IeIaxUnknown, IAX2IeByte);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeIaxUnknown(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };

  /**Constructor when sending an unknown message*/
  IAX2IeIaxUnknown(BYTE newValue) : IAX2IeByte(newValue) { }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_iaxUnknown; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.iaxUnknown = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains how many messages are waiting*/
class IAX2IeMsgCount : public IAX2IeShort
{
  PCLASSINFO(IAX2IeMsgCount, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeMsgCount(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_msgCount; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.msgCount = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains a request for auto-answering*/
class IAX2IeAutoAnswer : public IAX2IeNone
{
  PCLASSINFO(IAX2IeAutoAnswer, IAX2IeNone);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeAutoAnswer(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_autoAnswer; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.autoAnswer = true;; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains a request for music on hold with Quelch*/
class IAX2IeMusicOnHold : public IAX2IeNone
{
  PCLASSINFO(IAX2IeMusicOnHold, IAX2IeNone);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeMusicOnHold(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeMusicOnHold() : IAX2IeNone() { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_musicOnHold; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.musicOnHold = true; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains a transfer request identifier*/
class IAX2IeTransferId : public IAX2IeInt
{
  PCLASSINFO(IAX2IeTransferId, IAX2IeInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeTransferId(BYTE length, BYTE *srcData) : IAX2IeInt(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_transferId; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.transferId = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the referring DNIs*/
class IAX2IeRdnis : public IAX2IeString
{
  PCLASSINFO(IAX2IeRdnis, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeRdnis(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_rdnis; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.rdnis = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains Provisioning - a great big data block */
class IAX2IeProvisioning : public IAX2IeBlockOfData
{
  PCLASSINFO(IAX2IeProvisioning, IAX2IeBlockOfData);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeProvisioning(BYTE length, BYTE *srcData) : IAX2IeBlockOfData   (length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_provisioning; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &/*res*/) {  }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains aes provisioning info*/
class IAX2IeAesProvisioning : public IAX2IeNone
{
  PCLASSINFO(IAX2IeAesProvisioning, IAX2IeNone);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeAesProvisioning(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_aesProvisioning; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &/*res*/) {  }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the date and time (in 32 bits)*/
class IAX2IeDateTime : public IAX2IeDateAndTime
{
  PCLASSINFO(IAX2IeDateTime, IAX2IeDateAndTime);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeDateTime(BYTE length, BYTE *srcData) : IAX2IeDateAndTime(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_dateTime; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.dateTime = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the device type*/
class IAX2IeDeviceType : public IAX2IeString
{
  PCLASSINFO(IAX2IeDeviceType, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeDeviceType(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_deviceType; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.deviceType = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the service identifier*/
class IAX2IeServiceIdent : public IAX2IeString
{
  PCLASSINFO(IAX2IeServiceIdent, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeServiceIdent(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_serviceIdent; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.serviceIdent = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the firmware version*/
class IAX2IeFirmwareVer : public IAX2IeShort
{
  PCLASSINFO(IAX2IeFirmwareVer, IAX2IeShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeFirmwareVer(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_firmwareVer; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.firmwareVer = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains firmware block description*/
class IAX2IeFwBlockDesc : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeFwBlockDesc, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeFwBlockDesc(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeFwBlockDesc(unsigned int newValue) : IAX2IeUInt(newValue) { }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_fwBlockDesc; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.fwBlockDesc = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the block of firmware data */
class IAX2IeFwBlockData : public IAX2IeBlockOfData
{
  PCLASSINFO(IAX2IeFwBlockData, IAX2IeBlockOfData);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeFwBlockData(BYTE length, BYTE *srcData) : IAX2IeBlockOfData(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_fwBlockData; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.fwBlockData = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the Provisioning version*/
class IAX2IeProvVer : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeProvVer, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeProvVer(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**Construct with a predefined value (Typically used prior to transmission)*/
  IAX2IeProvVer(unsigned int newValue) : IAX2IeUInt(newValue) { }

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_provVer; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.provVer = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the calling presentation*/
class IAX2IeCallingPres : public IAX2IeByte
{
  PCLASSINFO(IAX2IeCallingPres, IAX2IeByte);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCallingPres(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callingPres; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.callingPres = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the calling type of number*/
class IAX2IeCallingTon : public IAX2IeByte
{
  PCLASSINFO(IAX2IeCallingTon, IAX2IeByte);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCallingTon(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callingTon; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.callingTon = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the calling transit network select */
class IAX2IeCallingTns : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeCallingTns, IAX2IeUShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCallingTns(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callingTns; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.callingTns = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the supported sampling rates*/
class IAX2IeSamplingRate : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeSamplingRate, IAX2IeUShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeSamplingRate(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_samplingRate; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.samplingRate = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the encryption format*/
class IAX2IeEncryption : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeEncryption, IAX2IeUShort);
 public:
  /**Specify the different encryption methods */
  enum IAX2IeEncryptionMethod {
    encryptAes128 = 1    /*!< Specify to use AES 128 bit encryption */
  };

  /**Constructor to specify a particular encryption method */
  IAX2IeEncryption(IAX2IeEncryptionMethod method = encryptAes128);

  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeEncryption(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_encryption; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.encryptionMethods = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the encryption key (raw)*/
class IAX2IeEncKey : public IAX2IeString
{
  PCLASSINFO(IAX2IeEncKey, IAX2IeString);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeEncKey(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_encKey; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.encKey = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains data for codec negotiation. */
class IAX2IeCodecPrefs : public IAX2IeByte
{
  PCLASSINFO(IAX2IeCodecPrefs, IAX2IeByte);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeCodecPrefs(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_codecPrefs; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.codecPrefs = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the received jitter */
class IAX2IeReceivedJitter : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedJitter, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeReceivedJitter(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_recJitter; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedJitter = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the received loss */
class IAX2IeReceivedLoss : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedLoss, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeReceivedLoss(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_recLoss; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedLoss = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the received frames */
class IAX2IeReceivedFrames : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedFrames, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeReceivedFrames(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_recPackets; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedPackets = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the received delay */
class IAX2IeReceivedDelay : public IAX2IeUShort
{
  PCLASSINFO(IAX2IeReceivedDelay, IAX2IeUShort);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeReceivedDelay(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_recDelay; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedDelay = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the number of dropped frames */
class IAX2IeDroppedFrames : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeDroppedFrames, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeDroppedFrames(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_recDropped; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedDropped = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the number of frames received out of order */
class IAX2IeReceivedOoo : public IAX2IeUInt
{
  PCLASSINFO(IAX2IeReceivedOoo, IAX2IeUInt);
 public:
  /** Constructor from data read from the network.

  Contents are undefined if the network data is bogus/invalid */
  IAX2IeReceivedOoo(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };

  /**print this class (nicely) to the designated stream*/
  virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_recOoo; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.receivedOoo = dataValue; }
 protected:
};

///////////////////////////////////////////////////////////////////////
/**An Information Element that contains the Call Token - a mechanism to stop
   DOS attacks through setting up lots of calls

   The IAX2IeCallToken uses the HMAC SHA1 algorithm to secure the
   challenge message sent to the initiating computer. With this
   approach, it is not feasible for spoofing etc of the reply. You can
   readup on hmac-sha1 at http://en.wikipedia.org/wiki/HMAC */
class IAX2IeCallToken : public IAX2IeBinary
{
  PCLASSINFO(IAX2IeCallToken, IAX2IeBinary);
 public:
  /** Constructor from data read from the network.  Contents are
  undefined if the network data is bogus/invalid */
  IAX2IeCallToken(BYTE length, BYTE *srcData)
    : IAX2IeBinary(length, srcData) { };

  /** Build an empty IAX2IeCallToken, which is used in the new packet,
        as sent by the node initiating a call */
   IAX2IeCallToken() : IAX2IeBinary(0, NULL) {};

  /**print this class (nicely) to the designated stream*/
     virtual void PrintOn(ostream & str) const;

  /**Get the key value for this particular Information Element class */
  virtual BYTE GetKeyValue() const  { return ie_callToken; }

  /** Take the data from this IAX2Ie, and copy it into the IAX2IeData
      structure.  This is done on processing an incoming frame which
      contains IAX2Ie in the data section. */
  virtual void StoreDataIn(IAX2IeData &res) { res.callToken = dataValue; }

  /**Initialise the internal key, and the iKeyPad and oKeyPad
     variables, for the generation of the SHA1-HMAC keysequence. This
     initialisation happens once, at program startup. */
  static void InitialiseKey();

  /**Fill with a hash key sequence, that we will later verify*/
  void WriteKeySequence(PIPSocket::Address & remoteAddress);

  /**Examine the hash key sequence in the supplied IE, and see if it
     is valid. */
  static PBoolean ValidKeySequence (IAX2IeCallToken & cf,
				    PIPSocket::Address & remote);

 protected:
 /**Report the key sequence that should be built, provided the
    supplied time string and address */
  static PString ReportKeySequence(const PString & time, PIPSocket::Address & remote);

  /**The internal size of the hmac sha1 key, which the protocol sets
     at 64 bytes, as this is a 512 bit hash */
  enum {
    iKeyValue = 0x36, /*!< Speced in protocol, an ambiguitating value */
    oKeyValue = 0x5c, /*!< Same as iKeyValue, bitwise is very different.*/
    blockSize = 64    /*!< Size of the cypher. 64 bytes = 512 bits. */
  };

  /**The key used in generating the SHA1-HMAC hash. Key is required for
    handling incoming calls */
  static PString secretKey;

  /**Used for generating the SHA1-HMAC hash.  Initialised at program
    startup, saves on time later. */
  static BYTE iKeyPad[blockSize];

  /**Similar to the iKeyPad, an internal variable*/
  static BYTE oKeyPad[blockSize];
};
/////////////////////////////////////////////////////////////////////////////


PDECLARE_LIST (IAX2IeList, IAX2Ie *)
#ifdef DOC_PLUS_PLUS
/**An array of IE* elements are stored in this list */
class IAX2IeList : public IAX2Ie *
{
#endif
 public:
  /**Destructor, so all eleents are destroyed on destruction */
  ~IAX2IeList();

  /**Access method, get pointer to information element at index.
     Returns NULL if index is out of bounds.
     This will remove the specified IAX2Ie from the list. */
  IAX2Ie *RemoveIeAt(PINDEX i);

  /**Access method, get pointer to last information element in the list.
     Returns NULL if index is out of bounds.
     This will remove the specified IAX2Ie from the list. */
  IAX2Ie *RemoveLastIe();

  /**Initialisation - Objects are not automatically deleted on removal */
  void Initialise() {  DisallowDeleteObjects(); }

  /**Delete item at a particular index */
  void DeleteAt(PINDEX idex);

  /**Test to see if list is empty - returns true if no elements stored in this list */
  PBoolean Empty() const { return GetSize() == 0; }

  /**Test to see if list is empty - returns true if no elements stored in this list */
  PBoolean IsEmpty() const { return GetSize() == 0; }

  /**Add a new IAX2Ie to the list */
  void AppendIe(IAX2Ie *newMember) { Append(newMember);}

  /**Get the number of bytes to store all these IAX2Ie's in a network packet */
  int GetBinaryDataSize() const;

  /**Get a pointer to the IAX2Ie which is stored at index i*/
  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:
 */