ies.h

Go to the documentation of this file.
00001 /*
00002  *
00003  * Inter Asterisk Exchange 2
00004  * 
00005  * The classes used to hold Information Elements.
00006  * 
00007  * Open Phone Abstraction Library (OPAL)
00008  *
00009  * Copyright (c) 2005 Indranet Technologies Ltd.
00010  *
00011  * The contents of this file are subject to the Mozilla Public License
00012  * Version 1.0 (the "License"); you may not use this file except in
00013  * compliance with the License. You may obtain a copy of the License at
00014  * http://www.mozilla.org/MPL/
00015  *
00016  * Software distributed under the License is distributed on an "AS IS"
00017  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
00018  * the License for the specific language governing rights and limitations
00019  * under the License.
00020  *
00021  * The Original Code is Open Phone Abstraction Library.
00022  *
00023  * The Initial Developer of the Original Code is Indranet Technologies Ltd.
00024  *
00025  * The author of this code is Derek J Smithies
00026  *
00027  *  $Log: ies.h,v $
00028  *  Revision 1.3.2.1  2006/01/31 08:10:37  csoutheren
00029  *  Backported from CVS head
00030  *
00031  *  Revision 1.4  2006/01/31 03:28:47  csoutheren
00032  *  Removed compile warnings and changed functions args to const refs
00033  *
00034  *  Revision 1.3  2005/08/26 03:07:38  dereksmithies
00035  *  Change naming convention, so all class names contain the string "IAX2"
00036  *
00037  *  Revision 1.2  2005/08/24 01:38:38  dereksmithies
00038  *  Add encryption, iax2 style. Numerous tidy ups. Use the label iax2, not iax
00039  *
00040  *  Revision 1.1  2005/07/30 07:01:32  csoutheren
00041  *  Added implementation of IAX2 (Inter Asterisk Exchange 2) protocol
00042  *  Thanks to Derek Smithies of Indranet Technologies Ltd. for
00043  *  writing and contributing this code
00044  *
00045  *
00046  *
00047  *
00048  *
00049  */
00050 
00051 #ifndef IES_H
00052 #define IES_H
00053 
00054 #include <ptlib.h>
00055 #include <ptlib/sockets.h>
00056 #include <iax2/iedata.h>
00057 
00058 #ifdef P_USE_PRAGMA
00059 #pragma interface
00060 #endif
00061 
00062 
00063 class IAX2Ie;
00064 class IAX2Encryption;
00065 
00067 class IAX2Ie : public PObject
00068 { 
00069   PCLASSINFO(IAX2Ie, PObject);
00070  public:
00072   enum IAX2IeTypeCode {    
00073     ie_calledNumber      = 1,     
00074     ie_callingNumber     = 2,     
00075     ie_callingAni        = 3,     
00076     ie_callingName       = 4,     
00077     ie_calledContext     = 5,     
00078     ie_userName          = 6,     
00079     ie_password          = 7,     
00080     ie_capability        = 8,     
00081     ie_format            = 9,     
00082     ie_language          = 10,    
00083     ie_version           = 11,    
00084     ie_adsicpe           = 12,    
00085     ie_dnid              = 13,    
00086     ie_authMethods       = 14,    
00087     ie_challenge         = 15,    
00088     ie_md5Result         = 16,    
00089     ie_rsaResult         = 17,    
00090     ie_apparentAddr      = 18,    
00091     ie_refresh           = 19,    
00092     ie_dpStatus          = 20,    
00093     ie_callNo            = 21,    
00094     ie_cause             = 22,    
00095     ie_iaxUnknown        = 23,    
00096     ie_msgCount          = 24,    
00097     ie_autoAnswer        = 25,    
00098     ie_musicOnHold       = 26,    
00099     ie_transferId        = 27,    
00100     ie_rdnis             = 28,    
00101     ie_provisioning      = 29,    
00102     ie_aesProvisioning   = 30,    
00103     ie_dateTime          = 31,    
00104     ie_deviceType        = 32,    
00105     ie_serviceIdent      = 33,    
00106     ie_firmwareVer       = 34,    
00107     ie_fwBlockDesc       = 35,    
00108     ie_fwBlockData       = 36,    
00109     ie_provVer           = 37,    
00110     ie_callingPres       = 38,    
00111     ie_callingTon        = 39,    
00112     ie_callingTns        = 40,    
00113     ie_samplingRate      = 41,    
00114     ie_causeCode         = 42,    
00115     ie_encryption        = 43,    
00116     ie_encKey            = 44,    
00117     ie_codecPrefs        = 45,    
00118     ie_recJitter         = 46,    
00119     ie_recLoss           = 47,    
00120     ie_recPackets        = 48,    
00121     ie_recDelay          = 49,    
00122     ie_recDropped        = 50,    
00123     ie_recOoo            = 51     
00124   };
00125   
00128   
00130   IAX2Ie();
00131   
00133   virtual ~IAX2Ie() { };
00135   
00139   static IAX2Ie *BuildInformationElement(BYTE _typeCode, BYTE length, BYTE *srcData);     
00140   
00142   virtual BOOL IsValid() { return validData; }
00143   
00145   virtual BYTE GetLengthOfData() { return 0; }
00146   
00148   int GetBinarySize() { return 2 + GetLengthOfData(); }
00149   
00151   void PrintOn(ostream & str) const;
00152   
00154   virtual BYTE GetKeyValue() const  { return 255; }
00155   
00157   void SetData(int &/*newData*/) { PAssertAlways("Ie class cannnot set data value"); };
00158   
00160   int ReadData() { PAssertAlways("Ie class cannot read the internal data value"); return 0; };
00161   
00164   void WriteBinary(void *data, PINDEX & writeIndex);
00165   
00168   virtual void StoreDataIn(IAX2IeData &/*res*/) { PTRACE(0, "UNIMPLEMENTED FUNCTION"); }     
00170   
00171  protected:
00173   virtual void WriteBinary(BYTE * /*data*/) { PTRACE(0, "UNIMPLEMENTED FUNCTION"); }
00174   
00177   BOOL   validData;
00178 };
00179 
00181 
00182 class IAX2IeInvalidElement : public IAX2Ie
00183 {
00184   PCLASSINFO(IAX2IeInvalidElement, IAX2Ie);
00185  public:
00186   IAX2IeInvalidElement() : IAX2Ie() {};
00187   
00189   virtual BYTE GetlengthOfData() { return 0; }
00190   
00192   void PrintOn(ostream & str) const
00193     { str << "Invlalid Information Element" << endl; }
00194  protected:
00197   virtual void WriteBinary(BYTE * /*data*/) {  }
00198 };
00200 
00201 class IAX2IeNone : public IAX2Ie
00202 {
00203   PCLASSINFO(IAX2IeNone, IAX2Ie);
00206   
00210   IAX2IeNone(BYTE length, BYTE *srcData);     
00211   
00213   IAX2IeNone() : IAX2Ie() {}
00215   
00219   virtual BYTE GetLengthOfData() { return 0; }
00220   
00222   BYTE GetValue() { return 0; }
00223   
00225   void PrintOn(ostream & str) const;
00226   
00228   void SetData(void * /*newData*/) { PAssertAlways("IeNone cannot set data"); }
00229   
00231   int ReadData() { PAssertAlways("IeNone cannot read the internal data value"); return 0; }
00232   
00234  protected:
00237   virtual void WriteBinary(BYTE * /*data*/) {  }
00238 };
00239 
00241 
00242 class IAX2IeByte : public IAX2Ie
00243 {
00244   PCLASSINFO(IAX2IeByte, IAX2Ie);
00247   
00251   IAX2IeByte(BYTE length, BYTE *srcData);     
00252   
00254   IAX2IeByte(BYTE newValue) : IAX2Ie() { SetData(newValue); }
00255   
00257   IAX2IeByte() : IAX2Ie() { }
00259   
00263   virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
00264   
00266   void PrintOn(ostream & str) const;
00267   
00269   void SetData(BYTE newData) { dataValue = newData; validData = TRUE; }
00270   
00272   BYTE ReadData() { return dataValue; }
00273   
00275  protected:
00277   virtual void WriteBinary(BYTE *data) { data[0] = dataValue; }
00278   
00280   BYTE dataValue;
00281 };
00282 
00284 
00285 class IAX2IeChar : public IAX2Ie
00286 {
00287   PCLASSINFO(IAX2IeChar, IAX2Ie);
00290   
00294   IAX2IeChar(BYTE length, BYTE *srcData);     
00295   
00297   IAX2IeChar(char newValue) : IAX2Ie() { SetData(newValue); }
00298   
00300   IAX2IeChar() : IAX2Ie() { }
00302   
00306   virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
00307   
00309   void PrintOn(ostream & str) const;
00310   
00312   void SetData(char newData) { dataValue = newData; validData = TRUE; }
00313   
00315   char ReadData() { return dataValue; }
00316   
00318  protected:
00320   virtual void WriteBinary(BYTE *data) { data[0] = dataValue; }
00321   
00323   char dataValue;
00324 };
00325 
00327 
00328 class IAX2IeShort : public IAX2Ie
00329 {
00330   PCLASSINFO(IAX2IeShort, IAX2Ie);
00333   
00337   IAX2IeShort(BYTE length, BYTE *srcData);     
00338   
00340   IAX2IeShort(short newValue) : IAX2Ie() { SetData(newValue); }
00341   
00343   IAX2IeShort() : IAX2Ie() { }
00345   
00349   virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
00350   
00352   void PrintOn(ostream & str) const;
00353   
00355   void SetData(short newData) { dataValue = newData; validData = TRUE; }
00356   
00358   short ReadData() { return dataValue; }  
00360  protected:
00362   virtual void WriteBinary(BYTE *data);
00363   
00365   short dataValue;
00366 };
00368 
00369 class IAX2IeInt : public IAX2Ie
00370 {
00371   PCLASSINFO(IAX2IeInt, IAX2Ie);
00374   
00378   IAX2IeInt(BYTE length, BYTE *srcData);     
00379   
00381   IAX2IeInt(int  newValue) : IAX2Ie() { SetData(newValue); }
00382   
00384   IAX2IeInt() : IAX2Ie() { }
00386   
00390   virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
00391   
00393   void PrintOn(ostream & str) const;
00394   
00396   void SetData(int newData) { dataValue = newData; validData = TRUE; }
00397   
00399   int ReadData() { return dataValue; }
00400   
00402  protected:
00404   virtual void WriteBinary(BYTE *data);
00405   
00407   int dataValue;
00408 };
00410 
00411 class IAX2IeUShort : public IAX2Ie
00412 {
00413   PCLASSINFO(IAX2IeUShort, IAX2Ie);
00416   
00420   IAX2IeUShort(BYTE length, BYTE *srcData);     
00421   
00423   IAX2IeUShort(unsigned short newValue) : IAX2Ie() { SetData(newValue); }
00424   
00426   IAX2IeUShort() : IAX2Ie() {}
00428   
00432   virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
00433   
00435   void PrintOn(ostream & str) const;
00436   
00438   void SetData(unsigned short newData) { dataValue = newData; validData = TRUE; }
00439   
00441   unsigned short ReadData() { return dataValue; }         
00443  protected:
00445   virtual void WriteBinary(BYTE *data);
00446   
00448   unsigned short dataValue;
00449 };
00451 
00452 class IAX2IeUInt : public IAX2Ie
00453 {
00454   PCLASSINFO(IAX2IeUInt, IAX2Ie);
00457   
00461   IAX2IeUInt(BYTE length, BYTE *srcData);     
00462   
00464   IAX2IeUInt() : IAX2Ie() {}
00465   
00467   IAX2IeUInt(unsigned int newValue) { SetData(newValue); }
00469   
00473   virtual BYTE GetLengthOfData() { return sizeof(dataValue); }
00474   
00476   void PrintOn(ostream & str) const;
00477   
00479   void SetData(unsigned int &newData) { dataValue = newData; validData = TRUE; }
00480   
00482   unsigned int ReadData() { return dataValue; }          
00484   
00485  protected:
00487   virtual void WriteBinary(BYTE *data);
00488   
00490   unsigned int dataValue;
00491 };
00492 
00494 
00495 class IAX2IeString : public IAX2Ie
00496 {
00497   PCLASSINFO(IAX2IeString, IAX2Ie);
00500   
00501  public:
00505   IAX2IeString(BYTE length, BYTE *srcData);     
00506   
00508   IAX2IeString(const PString & newValue) : IAX2Ie() { SetData(newValue); }
00509   
00511   IAX2IeString(const char * newValue) : IAX2Ie() { SetData(newValue); }
00512   
00514   IAX2IeString() : IAX2Ie() {}
00516   
00520   virtual BYTE GetLengthOfData();
00521   
00523   void PrintOn(ostream & str) const;
00524   
00526   void SetData(const PString & newData);
00527   
00529   void SetData(const char * newData);
00530   
00532   PString ReadData() { return dataValue; }          
00534   
00535  protected:
00537   virtual void WriteBinary(BYTE *data);
00538   
00540   PString dataValue;
00541 };
00543 
00544 class IAX2IeDateAndTime : public IAX2Ie
00545 {
00546   PCLASSINFO(IAX2IeDateAndTime, IAX2Ie);
00549   
00550  public:
00554   IAX2IeDateAndTime(BYTE length, BYTE *srcData);     
00555   
00557   IAX2IeDateAndTime(const PTime & newValue) : IAX2Ie() { SetData(newValue); }
00558   
00560   IAX2IeDateAndTime() : IAX2Ie() {}
00562   
00566   void PrintOn(ostream & str) const;
00567   
00569   virtual BYTE GetLengthOfData() { return 4; }
00570   
00572   void SetData(const PTime & newData) { dataValue = newData; validData = TRUE; }
00573   
00575   PTime ReadData() { return dataValue; }
00577  protected:
00579   virtual void WriteBinary(BYTE *data);
00580   
00582   PTime dataValue;
00583 };
00585 
00586 class IAX2IeBlockOfData : public IAX2Ie
00587 {
00588   PCLASSINFO(IAX2IeBlockOfData, IAX2Ie);
00591   
00592  public:
00596   IAX2IeBlockOfData(BYTE length, BYTE *srcData);     
00597   
00599   IAX2IeBlockOfData(const PBYTEArray & newData) : IAX2Ie() { SetData(newData); }
00600   
00602   IAX2IeBlockOfData() : IAX2Ie() {}
00604   
00608   void PrintOn(ostream & str) const;
00609   
00611   virtual BYTE GetLengthOfData() { return (BYTE)dataValue.GetSize(); }
00612   
00614   void SetData(const PBYTEArray & newData) { dataValue = newData; validData = TRUE; }
00615   
00617   PBYTEArray ReadData() { return dataValue; }
00618   
00620  protected:
00622   virtual void WriteBinary(BYTE *data);
00623   
00625   PBYTEArray dataValue;
00626 };
00628 
00629 class IAX2IeSockaddrIn : public IAX2Ie
00630 {
00631   PCLASSINFO(IAX2IeSockaddrIn, IAX2Ie);
00634   
00635  public:
00639   IAX2IeSockaddrIn(BYTE length, BYTE *srcData);     
00640   
00642   IAX2IeSockaddrIn(const PIPSocket::Address & addr, PINDEX port) : IAX2Ie() { SetData(addr, port); }
00643   
00645   IAX2IeSockaddrIn() : IAX2Ie() {}
00646   
00648   ~IAX2IeSockaddrIn() { } ;
00650   
00654   void PrintOn(ostream & str) const;
00655   
00657   virtual BYTE GetLengthOfData() { return sizeof(struct sockaddr_in); }
00658   
00659   
00661   void SetData(const PIPSocket::Address & newAddr, PINDEX newPort) 
00662     { dataValue = newAddr; portNumber = newPort; validData = TRUE; }
00663   
00665   PIPSocket::Address ReadData() { return dataValue; }
00666   
00668  protected:
00670   virtual void WriteBinary(BYTE *data);
00671   
00673   PIPSocket::Address dataValue;
00674   
00676   PINDEX               portNumber;
00677 };
00678 
00680 
00681 class IAX2IeCalledNumber : public IAX2IeString
00682 {
00683   PCLASSINFO(IAX2IeCalledNumber, IAX2IeString);
00684  public:
00688   IAX2IeCalledNumber(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) {};
00689   
00691   IAX2IeCalledNumber(const PString & newValue) { SetData(newValue); }
00692   
00694   void PrintOn(ostream & str) const;
00695   
00697   virtual BYTE GetKeyValue() const  { return ie_calledNumber; }
00698   
00701   virtual void StoreDataIn(IAX2IeData &res) { res.calledNumber = dataValue; }
00702  protected:
00703 };
00705 
00706 class IAX2IeCallingNumber : public IAX2IeString
00707 {
00708   PCLASSINFO(IAX2IeCallingNumber, IAX2IeString);
00709  public:
00713   IAX2IeCallingNumber(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00714   
00716   IAX2IeCallingNumber(const PString & newValue)  { SetData(newValue); } 
00717   
00719   void PrintOn(ostream & str) const;
00720   
00722   virtual BYTE GetKeyValue() const  { return ie_callingNumber; }
00723   
00726   virtual void StoreDataIn(IAX2IeData &res) { res.callingNumber = dataValue; }     
00727  protected:
00728 };
00729 
00731 
00732 class IAX2IeCallingAni : public IAX2IeString
00733 {
00734   PCLASSINFO(IAX2IeCallingAni, IAX2IeString);
00735  public:
00739   IAX2IeCallingAni(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00740   
00742   IAX2IeCallingAni(const PString & newValue) { SetData(newValue); }
00743   
00745   void PrintOn(ostream & str) const;
00746   
00748   virtual BYTE GetKeyValue() const  { return ie_callingAni; }
00749   
00752   virtual void StoreDataIn(IAX2IeData &res) { res.callingAni = dataValue; }     
00753  protected:
00754 };
00755 
00757 
00758 class IAX2IeCallingName : public IAX2IeString
00759 {
00760   PCLASSINFO(IAX2IeCallingName, IAX2IeString);
00761  public:
00765   IAX2IeCallingName(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00766   
00768   IAX2IeCallingName(const PString & newValue) { SetData(newValue); }
00769   
00771   void PrintOn(ostream & str) const;
00772   
00774   virtual BYTE GetKeyValue() const  { return ie_callingName; }
00775   
00778   virtual void StoreDataIn(IAX2IeData &res) { res.callingName = dataValue; }     
00779  protected:
00780 };
00781 
00783 
00784 class IAX2IeCalledContext : public IAX2IeString
00785 {
00786   PCLASSINFO(IAX2IeCalledContext, IAX2IeString);
00787  public:
00791   IAX2IeCalledContext(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00792   
00794   IAX2IeCalledContext(const PString & newValue) { SetData(newValue); }
00795   
00797   void PrintOn(ostream & str) const;
00798   
00800   virtual BYTE GetKeyValue() const  { return ie_calledContext; }
00801   
00804   virtual void StoreDataIn(IAX2IeData &res) { res.calledContext = dataValue; }     
00805  protected:
00806 };
00807 
00809 
00810 class IAX2IeUserName : public IAX2IeString
00811 {
00812   PCLASSINFO(IAX2IeUserName, IAX2IeString);
00813  public:
00817   IAX2IeUserName(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00818   
00820   IAX2IeUserName(const PString & newValue)  { SetData(newValue); }
00821   
00823   void PrintOn(ostream & str) const;
00824   
00826   virtual BYTE GetKeyValue() const  { return ie_userName; }
00827   
00830   virtual void StoreDataIn(IAX2IeData &res) { res.userName = dataValue; }     
00831  protected:
00832 };
00833 
00835 
00836 class IAX2IePassword : public IAX2IeString
00837 {
00838   PCLASSINFO(IAX2IePassword, IAX2IeString);
00839  public:
00843   IAX2IePassword(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00844   
00846   IAX2IePassword(const PString & newValue) { SetData(newValue); }
00847   
00849   void PrintOn(ostream & str) const;
00850   
00852   virtual BYTE GetKeyValue() const  { return ie_password; }
00853   
00856   virtual void StoreDataIn(IAX2IeData &res) { res.password = dataValue; }     
00857  protected:
00858 };
00859 
00861 
00862 class IAX2IeCapability : public IAX2IeUInt
00863 {
00864   PCLASSINFO(IAX2IeCapability, IAX2IeUInt);
00865  public:
00869   IAX2IeCapability(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
00870   
00872   IAX2IeCapability(unsigned int newValue) : IAX2IeUInt(newValue) { }
00873   
00875   void PrintOn(ostream & str) const;
00876   
00878   virtual BYTE GetKeyValue() const  { return ie_capability; }
00879   
00882   virtual void StoreDataIn(IAX2IeData &res) { res.capability = dataValue; }     
00883  protected:
00884 };
00885 
00887 
00888 class IAX2IeFormat : public IAX2IeUInt
00889 {
00890   PCLASSINFO(IAX2IeFormat, IAX2IeUInt);
00891  public:
00895   IAX2IeFormat(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
00896   
00898   IAX2IeFormat(unsigned int newValue) : IAX2IeUInt(newValue) { }
00899   
00901   void PrintOn(ostream & str) const;
00902   
00904   virtual BYTE GetKeyValue() const  { return ie_format; }
00905   
00908   virtual void StoreDataIn(IAX2IeData &res) { res.format = dataValue; }     
00909  protected:
00910 };
00911 
00913 
00914 class IAX2IeLanguage : public IAX2IeString
00915 {
00916   PCLASSINFO(IAX2IeLanguage, IAX2IeString);
00917  public:
00921   IAX2IeLanguage(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00922   
00924   IAX2IeLanguage(const PString & newValue) { SetData(newValue); }
00925   
00927   void PrintOn(ostream & str) const;
00928   
00930   virtual BYTE GetKeyValue() const  { return ie_language; }
00931   
00934   virtual void StoreDataIn(IAX2IeData &res) { res.language = dataValue; }     
00935  protected:
00936 };
00937 
00939 
00940 class IAX2IeVersion : public IAX2IeShort
00941 {
00942   PCLASSINFO(IAX2IeVersion, IAX2IeShort);
00943  public:
00947   IAX2IeVersion(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
00948   
00950   IAX2IeVersion() { dataValue = 2; validData = TRUE; }
00951   
00953   void PrintOn(ostream & str) const;
00954   
00956   virtual BYTE GetKeyValue() const  { return ie_version; }
00957   
00960   virtual void StoreDataIn(IAX2IeData &res) { res.version = dataValue; }     
00961  protected:
00962 };
00963 
00965 
00966 class IAX2IeAdsicpe : public IAX2IeShort
00967 {
00968   PCLASSINFO(IAX2IeAdsicpe, IAX2IeShort);
00969  public:
00973   IAX2IeAdsicpe(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
00974   
00976   void PrintOn(ostream & str) const;
00977   
00979   virtual BYTE GetKeyValue() const  { return ie_adsicpe; }
00980   
00983   virtual void StoreDataIn(IAX2IeData &res) { res.adsicpe = dataValue; }     
00984  protected:
00985 };
00986 
00988 
00989 class IAX2IeDnid : public IAX2IeString
00990 {
00991   PCLASSINFO(IAX2IeDnid, IAX2IeString);
00992  public:
00996   IAX2IeDnid(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
00997   
00999   IAX2IeDnid(const PString & newValue)  { SetData(newValue); }
01000   
01002   void PrintOn(ostream & str) const;
01003   
01005   virtual BYTE GetKeyValue() const  { return ie_dnid; }
01006   
01009   virtual void StoreDataIn(IAX2IeData &res) { res.dnid = dataValue; }     
01010  protected:
01011 };
01012 
01014 
01015 class IAX2IeAuthMethods : public IAX2IeShort
01016 {
01017   PCLASSINFO(IAX2IeAuthMethods, IAX2IeShort);
01018  public:
01022   IAX2IeAuthMethods(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
01023   
01025   IAX2IeAuthMethods(short newValue) { SetData(newValue); }
01026   
01028   void PrintOn(ostream & str) const;
01029   
01031   virtual BYTE GetKeyValue() const  { return ie_authMethods; }
01032   
01035   virtual void StoreDataIn(IAX2IeData &res) { res.authMethods = dataValue; }     
01036   
01038   static BOOL IsRsaAuthentication(short testValue) { return InternalIsRsa(testValue); }
01039   
01041   static BOOL IsMd5Authentication(short testValue) { return InternalIsMd5(testValue); }
01042   
01044   static BOOL IsPlainTextAuthentication(short testValue) { return InternalIsPlainText(testValue); }     
01045   
01047   BOOL IsRsaAuthentication() { if (IsValid()) return InternalIsRsa(dataValue); else return FALSE; }
01048   
01050   BOOL IsMd5Authentication() { if (IsValid()) return InternalIsMd5(dataValue); else return FALSE; }
01051   
01053   BOOL IsPlainTextAuthentication() { if (IsValid()) return InternalIsPlainText(dataValue); else return FALSE; }
01054   
01055  protected:
01056   
01058   static BOOL InternalIsRsa(short testValue) { return testValue  && 0x04; }
01059   
01061   static BOOL InternalIsMd5(short testValue) { return testValue  && 0x02; }
01062   
01064   static BOOL InternalIsPlainText(short testValue) { return testValue  && 0x01; }
01065 };
01066 
01068 
01069 class IAX2IeChallenge : public IAX2IeString
01070 {
01071   PCLASSINFO(IAX2IeChallenge, IAX2IeString);
01072  public:
01076   IAX2IeChallenge(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01077   
01079   IAX2IeChallenge(const PString & newValue) { SetData(newValue); }
01080   
01082   void PrintOn(ostream & str) const;
01083   
01085   virtual BYTE GetKeyValue() const  { return ie_challenge; }
01086   
01089   virtual void StoreDataIn(IAX2IeData &res) { res.challenge = dataValue; }     
01090  protected:
01091 };
01092 
01094 
01095 class IAX2IeMd5Result : public IAX2IeString
01096 {
01097   PCLASSINFO(IAX2IeMd5Result, IAX2IeString);
01098  public:
01102   IAX2IeMd5Result(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01103   
01105   IAX2IeMd5Result(const PString & newValue) { SetData(newValue); }
01106   
01108   IAX2IeMd5Result(const PString & challenge, const PString & password);
01109   
01111   IAX2IeMd5Result(IAX2Encryption & encryption);
01112   
01114   void InitializeChallengePassword(const PString & newChallenge, const PString & newPassword);
01115 
01117   void PrintOn(ostream & str) const;
01118   
01120   virtual BYTE GetKeyValue() const  { return ie_md5Result; }
01121   
01124   virtual void StoreDataIn(IAX2IeData &res) { res.md5Result = dataValue; }     
01125 
01128   PBYTEArray & GetDataBlock() { return dataBlock; }
01129 
01130  protected:
01131 
01133   PBYTEArray dataBlock;
01134 };
01135 
01137 
01138 class IAX2IeRsaResult : public IAX2IeString
01139 {
01140   PCLASSINFO(IAX2IeRsaResult, IAX2IeString);
01141  public:
01145   IAX2IeRsaResult(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01146   
01148   IAX2IeRsaResult(const PString & newValue) { SetData(newValue); }
01149   
01151   void PrintOn(ostream & str) const;
01152   
01154   virtual BYTE GetKeyValue() const  { return ie_rsaResult; }
01155   
01158   virtual void StoreDataIn(IAX2IeData &res) { res.rsaResult = dataValue; }
01159  protected:
01160 };
01161 
01163 
01164 class IAX2IeApparentAddr : public IAX2IeSockaddrIn
01165 {
01166   PCLASSINFO(IAX2IeApparentAddr, IAX2IeSockaddrIn);
01167  public:
01171   IAX2IeApparentAddr(BYTE length, BYTE *srcData) : IAX2IeSockaddrIn(length, srcData) { };
01172   
01174   ~IAX2IeApparentAddr() { };
01175   
01177   void PrintOn(ostream & str) const;
01178   
01180   virtual BYTE GetKeyValue() const  { return ie_apparentAddr; }
01181   
01184   virtual void StoreDataIn(IAX2IeData &res) { res.apparentAddr = dataValue; }     
01185  protected:
01186 };
01187 
01189 
01190 class IAX2IeRefresh : public IAX2IeShort
01191 {
01192   PCLASSINFO(IAX2IeRefresh, IAX2IeShort);
01193  public:
01197   IAX2IeRefresh(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
01198   
01200   void PrintOn(ostream & str) const;
01201   
01203   virtual BYTE GetKeyValue() const  { return ie_refresh; }
01204   
01207   virtual void StoreDataIn(IAX2IeData &res) { res.refresh = dataValue; }     
01208  protected:
01209 };
01210 
01212 
01213 class IAX2IeDpStatus : public IAX2IeShort
01214 {
01215   PCLASSINFO(IAX2IeDpStatus, IAX2IeShort);
01216  public:
01220   IAX2IeDpStatus(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
01221   
01223   void PrintOn(ostream & str) const;
01224   
01226   virtual BYTE GetKeyValue() const  { return ie_dpStatus; }
01227   
01230   virtual void StoreDataIn(IAX2IeData &res) { res.dpStatus = dataValue; }     
01231  protected:
01232 };
01233 
01235 
01236 class IAX2IeCallNo : public IAX2IeShort
01237 {
01238   PCLASSINFO(IAX2IeCallNo, IAX2IeShort);
01239  public:
01243   IAX2IeCallNo(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
01244   
01246   void PrintOn(ostream & str) const;
01247   
01249   virtual BYTE GetKeyValue() const  { return ie_callNo; }
01250   
01253   virtual void StoreDataIn(IAX2IeData &res) { res.callNo = dataValue; }     
01254  protected:
01255 };
01256 
01258 
01259 class IAX2IeCause : public IAX2IeString
01260 {
01261   PCLASSINFO(IAX2IeCause, IAX2IeString);
01262  public:
01266   IAX2IeCause(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01267   
01269   IAX2IeCause(const PString & newValue) : IAX2IeString(newValue) { }
01270   
01272   IAX2IeCause(const char *newValue) : IAX2IeString(newValue) { }
01273   
01275   void PrintOn(ostream & str) const;
01276   
01278   virtual BYTE GetKeyValue() const  { return ie_cause; }
01279   
01282   virtual void StoreDataIn(IAX2IeData &res) { res.cause = dataValue; }     
01283  protected:
01284 };
01285 
01287 
01288 class IAX2IeIaxUnknown : public IAX2IeByte
01289 {
01290   PCLASSINFO(IAX2IeIaxUnknown, IAX2IeByte);
01291  public:
01295   IAX2IeIaxUnknown(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
01296   
01298   void PrintOn(ostream & str) const;
01299   
01301   virtual BYTE GetKeyValue() const  { return ie_iaxUnknown; }
01302   
01305   virtual void StoreDataIn(IAX2IeData &res) { res.iaxUnknown = dataValue; }     
01306  protected:
01307 };
01308 
01310 
01311 class IAX2IeMsgCount : public IAX2IeShort
01312 {
01313   PCLASSINFO(IAX2IeMsgCount, IAX2IeShort);
01314  public:
01318   IAX2IeMsgCount(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
01319   
01321   void PrintOn(ostream & str) const;
01322   
01324   virtual BYTE GetKeyValue() const  { return ie_msgCount; }
01325   
01328   virtual void StoreDataIn(IAX2IeData &res) { res.msgCount = dataValue; }     
01329  protected:
01330 };
01331 
01333 
01334 class IAX2IeAutoAnswer : public IAX2IeNone
01335 {
01336   PCLASSINFO(IAX2IeAutoAnswer, IAX2IeNone);
01337  public:
01341   IAX2IeAutoAnswer(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };
01342   
01344   void PrintOn(ostream & str) const;
01345   
01347   virtual BYTE GetKeyValue() const  { return ie_autoAnswer; }
01348   
01351   virtual void StoreDataIn(IAX2IeData &res) { res.autoAnswer = TRUE;; }     
01352  protected:
01353 };
01354 
01356 
01357 class IAX2IeMusicOnHold : public IAX2IeNone
01358 {
01359   PCLASSINFO(IAX2IeMusicOnHold, IAX2IeNone);
01360  public:
01364   IAX2IeMusicOnHold(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };
01365   
01367   void PrintOn(ostream & str) const;
01368   
01370   virtual BYTE GetKeyValue() const  { return ie_musicOnHold; }
01371   
01374   virtual void StoreDataIn(IAX2IeData &res) { res.musicOnHold = TRUE; }     
01375  protected:
01376 };
01377 
01379 
01380 class IAX2IeTransferId : public IAX2IeInt
01381 {
01382   PCLASSINFO(IAX2IeTransferId, IAX2IeInt);
01383  public:
01387   IAX2IeTransferId(BYTE length, BYTE *srcData) : IAX2IeInt(length, srcData) { };
01388   
01390   void PrintOn(ostream & str) const;
01391   
01393   virtual BYTE GetKeyValue() const  { return ie_transferId; }
01394   
01397   virtual void StoreDataIn(IAX2IeData &res) { res.transferId = dataValue; }     
01398  protected:
01399 };
01400 
01402 
01403 class IAX2IeRdnis : public IAX2IeString
01404 {
01405   PCLASSINFO(IAX2IeRdnis, IAX2IeString);
01406  public:
01410   IAX2IeRdnis(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01411   
01413   void PrintOn(ostream & str) const;
01414   
01416   virtual BYTE GetKeyValue() const  { return ie_rdnis; }
01417   
01420   virtual void StoreDataIn(IAX2IeData &res) { res.rdnis = dataValue; }     
01421  protected:
01422 };
01423 
01425 
01426 class IAX2IeProvisioning : public IAX2IeBlockOfData
01427 {
01428   PCLASSINFO(IAX2IeProvisioning, IAX2IeBlockOfData);
01429  public:
01433   IAX2IeProvisioning(BYTE length, BYTE *srcData) : IAX2IeBlockOfData   (length, srcData) { };
01434   
01436   void PrintOn(ostream & str) const;
01437   
01439   virtual BYTE GetKeyValue() const  { return ie_provisioning; }
01440   
01443   virtual void StoreDataIn(IAX2IeData &/*res*/) {  }     
01444  protected:
01445 };
01446 
01448 
01449 class IAX2IeAesProvisioning : public IAX2IeNone
01450 {
01451   PCLASSINFO(IAX2IeAesProvisioning, IAX2IeNone);
01452  public:
01456   IAX2IeAesProvisioning(BYTE length, BYTE *srcData) : IAX2IeNone(length, srcData) { };
01457   
01459   void PrintOn(ostream & str) const;
01460   
01462   virtual BYTE GetKeyValue() const  { return ie_aesProvisioning; }
01463   
01466   virtual void StoreDataIn(IAX2IeData &/*res*/) {  }     
01467  protected:
01468 };
01469 
01471 
01472 class IAX2IeDateTime : public IAX2IeDateAndTime
01473 {
01474   PCLASSINFO(IAX2IeDateTime, IAX2IeDateAndTime);
01475  public:
01479   IAX2IeDateTime(BYTE length, BYTE *srcData) : IAX2IeDateAndTime(length, srcData) { };
01480   
01482   void PrintOn(ostream & str) const;
01483   
01485   virtual BYTE GetKeyValue() const  { return ie_dateTime; }
01486   
01489   virtual void StoreDataIn(IAX2IeData &res) { res.dateTime = dataValue; }     
01490  protected:
01491 };
01492 
01494 
01495 class IAX2IeDeviceType : public IAX2IeString
01496 {
01497   PCLASSINFO(IAX2IeDeviceType, IAX2IeString);
01498  public:
01502   IAX2IeDeviceType(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01503   
01505   void PrintOn(ostream & str) const;
01506   
01508   virtual BYTE GetKeyValue() const  { return ie_deviceType; }
01509   
01512   virtual void StoreDataIn(IAX2IeData &res) { res.deviceType = dataValue; }     
01513  protected:
01514 };
01515 
01517 
01518 class IAX2IeServiceIdent : public IAX2IeString
01519 {
01520   PCLASSINFO(IAX2IeServiceIdent, IAX2IeString);
01521  public:
01525   IAX2IeServiceIdent(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01526   
01528   void PrintOn(ostream & str) const;
01529   
01531   virtual BYTE GetKeyValue() const  { return ie_serviceIdent; }
01532   
01535   virtual void StoreDataIn(IAX2IeData &res) { res.serviceIdent = dataValue; }     
01536  protected:
01537 };
01538 
01540 
01541 class IAX2IeFirmwareVer : public IAX2IeShort
01542 {
01543   PCLASSINFO(IAX2IeFirmwareVer, IAX2IeShort);
01544  public:
01548   IAX2IeFirmwareVer(BYTE length, BYTE *srcData) : IAX2IeShort(length, srcData) { };
01549   
01551   void PrintOn(ostream & str) const;
01552   
01554   virtual BYTE GetKeyValue() const  { return ie_firmwareVer; }
01555   
01558   virtual void StoreDataIn(IAX2IeData &res) { res.firmwareVer = dataValue; }     
01559  protected:
01560 };
01561 
01563 
01564 class IAX2IeFwBlockDesc : public IAX2IeUInt
01565 {
01566   PCLASSINFO(IAX2IeFwBlockDesc, IAX2IeUInt);
01567  public:
01571   IAX2IeFwBlockDesc(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01572   
01574   IAX2IeFwBlockDesc(unsigned int newValue) : IAX2IeUInt(newValue) { }
01575   
01577   void PrintOn(ostream & str) const;
01578   
01580   virtual BYTE GetKeyValue() const  { return ie_fwBlockDesc; }
01581   
01584   virtual void StoreDataIn(IAX2IeData &res) { res.fwBlockDesc = dataValue; }     
01585  protected:
01586 };
01587 
01589 
01590 class IAX2IeFwBlockData : public IAX2IeBlockOfData
01591 {
01592   PCLASSINFO(IAX2IeFwBlockData, IAX2IeBlockOfData);
01593  public:
01597   IAX2IeFwBlockData(BYTE length, BYTE *srcData) : IAX2IeBlockOfData(length, srcData) { };
01598   
01600   void PrintOn(ostream & str) const;
01601   
01603   virtual BYTE GetKeyValue() const  { return ie_fwBlockData; }
01604   
01607   virtual void StoreDataIn(IAX2IeData &res) { res.fwBlockData = dataValue; }     
01608  protected:
01609 };
01610 
01612 
01613 class IAX2IeProvVer : public IAX2IeUInt
01614 {
01615   PCLASSINFO(IAX2IeProvVer, IAX2IeUInt);
01616  public:
01620   IAX2IeProvVer(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01621   
01623   IAX2IeProvVer(unsigned int newValue) : IAX2IeUInt(newValue) { }
01624   
01626   void PrintOn(ostream & str) const;
01627   
01629   virtual BYTE GetKeyValue() const  { return ie_provVer; }
01630   
01633   virtual void StoreDataIn(IAX2IeData &res) { res.provVer = dataValue; }     
01634  protected:
01635 };
01636 
01638 
01639 class IAX2IeCallingPres : public IAX2IeByte
01640 {
01641   PCLASSINFO(IAX2IeCallingPres, IAX2IeByte);
01642  public:
01646   IAX2IeCallingPres(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
01647   
01649   void PrintOn(ostream & str) const;
01650   
01652   virtual BYTE GetKeyValue() const  { return ie_callingPres; }
01653   
01656   virtual void StoreDataIn(IAX2IeData &res) { res.callingPres = dataValue; }     
01657  protected:
01658 };
01659 
01661 
01662 class IAX2IeCallingTon : public IAX2IeByte
01663 {
01664   PCLASSINFO(IAX2IeCallingTon, IAX2IeByte);
01665  public:
01669   IAX2IeCallingTon(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
01670   
01672   void PrintOn(ostream & str) const;
01673   
01675   virtual BYTE GetKeyValue() const  { return ie_callingTon; }
01676   
01679   virtual void StoreDataIn(IAX2IeData &res) { res.callingTon = dataValue; }     
01680  protected:
01681 };
01682 
01684 
01685 class IAX2IeCallingTns : public IAX2IeUShort
01686 {
01687   PCLASSINFO(IAX2IeCallingTns, IAX2IeUShort);
01688  public:
01692   IAX2IeCallingTns(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
01693   
01695   void PrintOn(ostream & str) const;
01696   
01698   virtual BYTE GetKeyValue() const  { return ie_callingTns; }
01699   
01702   virtual void StoreDataIn(IAX2IeData &res) { res.callingTns = dataValue; }     
01703  protected:
01704 };
01705 
01707 
01708 class IAX2IeSamplingRate : public IAX2IeUShort
01709 {
01710   PCLASSINFO(IAX2IeSamplingRate, IAX2IeUShort);
01711  public:
01715   IAX2IeSamplingRate(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
01716   
01718   void PrintOn(ostream & str) const;
01719   
01721   virtual BYTE GetKeyValue() const  { return ie_samplingRate; }
01722   
01725   virtual void StoreDataIn(IAX2IeData &res) { res.samplingRate = dataValue; }     
01726  protected:
01727 };
01728 
01730 
01731 class IAX2IeEncryption : public IAX2IeUShort
01732 {
01733   PCLASSINFO(IAX2IeEncryption, IAX2IeUShort);
01734  public:
01736   enum IAX2IeEncryptionMethod {
01737     encryptAes128 = 1    
01738   };
01739 
01741   IAX2IeEncryption(IAX2IeEncryptionMethod method = encryptAes128);
01742 
01746   IAX2IeEncryption(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
01747   
01749   void PrintOn(ostream & str) const;
01750   
01752   virtual BYTE GetKeyValue() const  { return ie_encryption; }
01753   
01756   virtual void StoreDataIn(IAX2IeData &res) { res.encryptionMethods = dataValue; }
01757  protected:
01758 };
01759 
01761 
01762 class IAX2IeEncKey : public IAX2IeString
01763 {
01764   PCLASSINFO(IAX2IeEncKey, IAX2IeString);
01765  public:
01769   IAX2IeEncKey(BYTE length, BYTE *srcData) : IAX2IeString(length, srcData) { };
01770   
01772   void PrintOn(ostream & str) const;
01773   
01775   virtual BYTE GetKeyValue() const  { return ie_encKey; }
01776   
01779   virtual void StoreDataIn(IAX2IeData &res) { res.encKey = dataValue; }     
01780  protected:
01781 };
01782 
01784 
01785 class IAX2IeCodecPrefs : public IAX2IeByte
01786 {
01787   PCLASSINFO(IAX2IeCodecPrefs, IAX2IeByte);
01788  public:
01792   IAX2IeCodecPrefs(BYTE length, BYTE *srcData) : IAX2IeByte(length, srcData) { };
01793   
01795   void PrintOn(ostream & str) const;
01796   
01798   virtual BYTE GetKeyValue() const  { return ie_codecPrefs; }
01799   
01802   virtual void StoreDataIn(IAX2IeData &res) { res.codecPrefs = dataValue; }     
01803  protected:
01804 };
01805 
01807 
01808 class IAX2IeReceivedJitter : public IAX2IeUInt
01809 {
01810   PCLASSINFO(IAX2IeReceivedJitter, IAX2IeUInt);
01811  public:
01815   IAX2IeReceivedJitter(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01816   
01818   void PrintOn(ostream & str) const;
01819   
01821   virtual BYTE GetKeyValue() const  { return ie_recJitter; }
01822   
01825   virtual void StoreDataIn(IAX2IeData &res) { res.receivedJitter = dataValue; }     
01826  protected:
01827 };
01828 
01830 
01831 class IAX2IeReceivedLoss : public IAX2IeUInt
01832 {
01833   PCLASSINFO(IAX2IeReceivedLoss, IAX2IeUInt);
01834  public:
01838   IAX2IeReceivedLoss(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01839   
01841   void PrintOn(ostream & str) const;
01842   
01844   virtual BYTE GetKeyValue() const  { return ie_recLoss; }
01845   
01848   virtual void StoreDataIn(IAX2IeData &res) { res.receivedLoss = dataValue; }     
01849  protected:
01850 };
01851 
01853 
01854 class IAX2IeReceivedFrames : public IAX2IeUInt
01855 {
01856   PCLASSINFO(IAX2IeReceivedFrames, IAX2IeUInt);
01857  public:
01861   IAX2IeReceivedFrames(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01862   
01864   void PrintOn(ostream & str) const;
01865   
01867   virtual BYTE GetKeyValue() const  { return ie_recPackets; }
01868   
01871   virtual void StoreDataIn(IAX2IeData &res) { res.receivedPackets = dataValue; }     
01872  protected:
01873 };
01874 
01876 
01877 class IAX2IeReceivedDelay : public IAX2IeUShort
01878 {
01879   PCLASSINFO(IAX2IeReceivedDelay, IAX2IeUShort);
01880  public:
01884   IAX2IeReceivedDelay(BYTE length, BYTE *srcData) : IAX2IeUShort(length, srcData) { };
01885   
01887   void PrintOn(ostream & str) const;
01888   
01890   virtual BYTE GetKeyValue() const  { return ie_recDelay; }
01891   
01894   virtual void StoreDataIn(IAX2IeData &res) { res.receivedDelay = dataValue; }     
01895  protected:
01896 };
01897 
01899 
01900 class IAX2IeDroppedFrames : public IAX2IeUInt
01901 {
01902   PCLASSINFO(IAX2IeDroppedFrames, IAX2IeUInt);
01903  public:
01907   IAX2IeDroppedFrames(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01908   
01910   void PrintOn(ostream & str) const;
01911   
01913   virtual BYTE GetKeyValue() const  { return ie_recDropped; }
01914   
01917   virtual void StoreDataIn(IAX2IeData &res) { res.receivedDropped = dataValue; }     
01918  protected:
01919 };
01920 
01922 
01923 class IAX2IeReceivedOoo : public IAX2IeUInt
01924 {
01925   PCLASSINFO(IAX2IeReceivedOoo, IAX2IeUInt);
01926  public:
01930   IAX2IeReceivedOoo(BYTE length, BYTE *srcData) : IAX2IeUInt(length, srcData) { };
01931   
01933   void PrintOn(ostream & str) const;
01934   
01936   virtual BYTE GetKeyValue() const  { return ie_recOoo; }
01937   
01940   virtual void StoreDataIn(IAX2IeData &res) { res.receivedOoo = dataValue; }     
01941  protected:
01942 };
01943 
01945 
01946 
01947 PDECLARE_LIST (IAX2IeList, IAX2Ie *)
01948 #ifdef DOC_PLUS_PLUS 
01949 
01950 class IAX2IeList : public IAX2Ie *
01951 {
01952 #endif
01953  public:
01955   ~IAX2IeList();
01956   
01960   IAX2Ie *RemoveIeAt(PINDEX i);
01961   
01965   IAX2Ie *RemoveLastIe();
01966   
01968   void Initialise() {  DisallowDeleteObjects(); }
01969   
01971   void DeleteAt(PINDEX idex);
01972   
01974   BOOL Empty() const { return GetSize() == 0; }
01975   
01977   BOOL IsEmpty() const { return GetSize() == 0; }
01978   
01980   void AppendIe(IAX2Ie *newMember) { Append(newMember);}
01981   
01983   int GetBinaryDataSize() const;
01984   
01986   IAX2Ie * GetIeAt(int i) const;
01987   
01988  protected:
01989   
01990 };
01991 
01992 
01993 #endif // IAX_IES_H
01994 
01995 /* The comment below is magic for those who use emacs to edit this file. */
01996 /* With the comment below, the tab key does auto indent to 4 spaces.     */
01997 
01998 /*
01999  * Local Variables:
02000  * mode:c
02001  * c-file-style:linux
02002  * c-basic-offset:2
02003  * End:
02004  */

Generated on Mon Sep 25 16:20:07 2006 for OPAL by  doxygen 1.4.7