diameter_parser_api.h

/* BEGIN_COPYRIGHT                                                        */
/*                                                                        */
/* Open Diameter: Open-source software for the Diameter and               */
/*                Diameter related protocols                              */
/*                                                                        */
/* Copyright (C) 2002-2004 Open Diameter Project                          */
/*                                                                        */
/* This library is free software; you can redistribute it and/or modify   */
/* it under the terms of the GNU Lesser General Public License as         */
/* published by the Free Software Foundation; either version 2.1 of the   */
/* License, or (at your option) any later version.                        */
/*                                                                        */
/* This library is distributed in the hope that it will be useful,        */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of         */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      */
/* Lesser General Public License for more details.                        */
/*                                                                        */
/* You should have received a copy of the GNU Lesser General Public       */
/* License along with this library; if not, write to the Free Software    */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307    */
/* USA.                                                                   */
/*                                                                        */
/* In addition, when you copy and redistribute some or the entire part of */
/* the source code of this software with or without modification, you     */
/* MUST include this copyright notice in each copy.                       */
/*                                                                        */
/* If you make any changes that are appeared to be useful, please send    */
/* sources that include the changed part to                               */
/* diameter-developers@lists.sourceforge.net so that we can reflect your  */
/* changes to one unified version of this software.                       */
/*                                                                        */
/* END_COPYRIGHT                                                          */
// $Id: diameter_parser_api.h,v 1.26 2004/06/20 03:38:44 vfajardo Exp $

#ifndef __DIAMETER_PARSER_API_H__
#define __DIAMETER_PARSER_API_H__

#include <resultcodes.h>
#include <vector>
#include <map>
#include <string>
#include <list>
#include <boost/function/function0.hpp>
#include <boost/function/function1.hpp>

#include <ace/Basic_Types.h>
#include <ace/INET_Addr.h>
#include <ace/Message_Block.h>
#include <ace/Atomic_Op.h>
#include <ace/Synch.h>
#include <ace/Singleton.h>
#include <ace/Malloc_T.h>
#include <ace/Log_Msg.h>

#include "framework.h"

#define AAA_VERSION_MAJOR  0x01
#define AAA_VERSION_MINOR  0x00
#define AAA_VERSION_MICRO  0x05

#if defined (WIN32)
#  if defined (DIAMETERPARSER_EXPORTS)
#    define DIAMETERPARSER_EXPORT ACE_Proper_Export_Flag
#    define DIAMETERPARSER_EXPORT_ONLY ACE_Proper_Export_Flag
#    define DIAMETERPARSER_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
#    define DIAMETERPARSER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
#  else
#    define DIAMETERPARSER_EXPORT ACE_Proper_Import_Flag
#    define DIAMETERPARSER_EXPORT_ONLY
#    define DIAMETERPARSER_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
#    define DIAMETERPARSER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
#  endif   /* ! DIAMETERPARSER_EXPORTS */
#else
#  define DIAMETERPARSER_EXPORT
#  define DIAMETERPARSER_EXPORT_ONLY
#  define DIAMETERPARSER_SINGLETON_DECLARATION(T)
#  define DIAMETERPARSER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
#endif     /* WIN32 */

typedef char AAA_INT8;
typedef unsigned char AAA_UINT8;

typedef ACE_INET_Addr IP_ADDR;

typedef ACE_UINT32 AAACommandCode;

typedef ACE_UINT32 AAAVendorId;

typedef ACE_UINT32 AAA_AVPCode;

typedef void* AAASessionHandle;

typedef ACE_UINT32 AAAApplicationId;

typedef ACE_UINT32 AAAResultCode;

typedef enum {
    AAA_ERR_NOT_FOUND =     -2,
    AAA_ERR_FAILURE =       -1,
    AAA_ERR_SUCCESS =        0,
    AAA_ERR_NOMEM,
    AAA_ERR_PROTO,
    AAA_ERR_SECURITY,
    AAA_ERR_PARAMETER,
    AAA_ERR_CONFIG,
    AAA_ERR_UNKNOWN_CMD,
    AAA_ERR_MISSING_AVP,
    AAA_ERR_ALREADY_INIT,
    AAA_ERR_TIMED_OUT,
    AAA_ERR_CANNOT_SEND_MSG,
    AAA_ERR_ALREADY_REGISTERED,
    AAA_ERR_CANNOT_REGISTER,
    AAA_ERR_NOT_INITIALIZED,
    AAA_ERR_NETWORK_ERROR,
    AAA_ERR_MSG_UNPROCESSED,
    AAA_ERR_INVALID_STATE,
    AAA_ERR_PARSING_FAILED,
    AAA_ERR_UNKNOWN_SESSION,
    AAA_ERR_PARSING_ERROR
} AAAReturnCode;

typedef enum {
    AAA_AVP_DATA_TYPE,
    AAA_AVP_STRING_TYPE,
    AAA_AVP_ADDRESS_TYPE,          
    AAA_AVP_INTEGER32_TYPE,
    AAA_AVP_INTEGER64_TYPE,
    AAA_AVP_UINTEGER32_TYPE,
    AAA_AVP_UINTEGER64_TYPE,
    AAA_AVP_UTF8_STRING_TYPE,
    AAA_AVP_ENUM_TYPE,
    AAA_AVP_DIAMID_TYPE,
    AAA_AVP_DIAMURI_TYPE,
    AAA_AVP_GROUPED_TYPE,
    AAA_AVP_TIME_TYPE,
    AAA_AVP_IPFILTER_RULE_TYPE,
    AAA_AVP_CUSTOM_TYPE,
} AAA_AVPDataType;


typedef enum {
    AAA_AVP_FLAG_NONE =                 0,
    AAA_AVP_FLAG_MANDATORY =            0x1,
    AAA_AVP_FLAG_RESERVED =             0x2,
    AAA_AVP_FLAG_VENDOR_SPECIFIC =      0x4,
    AAA_AVP_FLAG_END_TO_END_ENCRYPT =   0x10,
    AAA_AVP_FLAG_UNKNOWN =              0x10000,
    AAA_AVP_FLAG_ENCRYPT =              0x40000,
} AAA_AVPFlagEnum;

typedef ACE_UINT32 AAA_AVPFlag;

class DIAMETERPARSER_EXPORT AAADictionaryEntry
{
 public:
  AAADictionaryEntry(AAA_AVPCode code, 
                     const char *name, 
                     AAA_AVPDataType type, 
                     AAAVendorId id, 
                     AAA_AVPFlag flg,
                     int proto);

  AAA_AVPCode     avpCode;  
  std::string     avpName;
  AAA_AVPDataType avpType;  
  AAAVendorId     vendorId; 
  AAA_AVPFlag     flags;    
  int             protocol; 
};

typedef enum {
    AAA_ACCT_EVENT = 1,
    AAA_ACCT_START = 2,
    AAA_ACCT_INTERIM = 3,
    AAA_ACCT_STOP = 4
} AAAAcctMessageType;

typedef enum {
    AAA_STYPE_AUTHENTICATION,  
    AAA_STYPE_ACCOUNTING       
} AAASessionType;

#define AAA_NO_VENDOR_ID                                0

#define AAA_BASE_APPLICATION_ID                         0

typedef ACE_INT32 diameter_integer32_t;
typedef ACE_UINT64 diameter_integer64_t;
typedef ACE_UINT32 diameter_unsigned32_t;
typedef ACE_UINT64 diameter_unsigned64_t;
typedef diameter_unsigned32_t diameter_enumerated_t;
typedef std::string diameter_octetstring_t;
typedef diameter_octetstring_t diameter_utf8string_t;  
typedef struct {
 public:
  std::string fqdn;
  ACE_UINT16 port; 
  AAA_UINT8 transport:2;
  AAA_UINT8 protocol:2;
  AAA_UINT8 scheme:2;
} diameter_uri_t;
typedef diameter_utf8string_t diameter_identity_t;
typedef diameter_octetstring_t diameter_ipaddress_t;   // XXX: this
                                                       // will be
                                                       // deprecated.
                                                       // Use
                                                       // diameter_address_t
                                                       // instead.
typedef struct {
  public:
  ACE_UINT16 type;
  diameter_octetstring_t value;
} diameter_address_t;

typedef class AAAAvpContainerList diameter_grouped_t;

typedef diameter_unsigned32_t diameter_time_t;

class AAA_UINT8_RANGE
{
  public:
  AAA_UINT8_RANGE(AAA_UINT8 first, AAA_UINT8 last) : first(first), last(last)
  {}
  AAA_UINT8_RANGE() 
  {}
  AAA_UINT8 first;
  AAA_UINT8 last;
};

class AAA_UINT16_RANGE
{
  public:
  AAA_UINT16_RANGE(ACE_UINT16 first, ACE_UINT16 last) : 
  first(first), last(last)
  {}
  AAA_UINT16_RANGE(ACE_UINT16 single) : first(single), last(single)
  {}
  AAA_UINT16_RANGE() 
  {}
  ACE_UINT16 first;
  ACE_UINT16 last;
};

enum {
  AAA_IPFILTER_RULE_SRCDST_EXACT,
  AAA_IPFILTER_RULE_SRCDST_MASK,
  AAA_IPFILTER_RULE_SRCDST_KEYWORD_ANY,
  AAA_IPFILTER_RULE_SRCDST_KEYWORD_ASSIGNED
};

class AAA_IPFILTER_RULE_SRCDST
{
 public:
  AAA_IPFILTER_RULE_SRCDST(AAA_UINT8 repr=AAA_IPFILTER_RULE_SRCDST_EXACT,
                           diameter_utf8string_t ipno=std::string(),
                           AAA_UINT8 bits=0,
                           bool mod=true) 
    : modifier(mod), representation(repr), ipno(ipno), bits(bits)
    {}
  bool modifier; 
  AAA_UINT8
  representation; 
  diameter_utf8string_t ipno; 
  AAA_UINT8 bits;

  std::list<AAA_UINT16_RANGE> portRangeList;   
};

enum {
  AAA_IPFILTER_RULE_IP_OPTION_SSRR=1,
  AAA_IPFILTER_RULE_IP_OPTION_LSRR,
  AAA_IPFILTER_RULE_IP_OPTION_RR,
  AAA_IPFILTER_RULE_IP_OPTION_TS
};

enum {
  AAA_IPFILTER_RULE_TCP_OPTION_MSS=1,
  AAA_IPFILTER_RULE_TCP_OPTION_WINDOW,
  AAA_IPFILTER_RULE_TCP_OPTION_SACK,
  AAA_IPFILTER_RULE_TCP_OPTION_TS,
  AAA_IPFILTER_RULE_TCP_OPTION_CC
};

enum {
  AAA_IPFILTER_RULE_TCP_FLAG_FIN=1,
  AAA_IPFILTER_RULE_TCP_FLAG_SYN, 
  AAA_IPFILTER_RULE_TCP_FLAG_RST, 
  AAA_IPFILTER_RULE_TCP_FLAG_PSH,
  AAA_IPFILTER_RULE_TCP_FLAG_ACK,
  AAA_IPFILTER_RULE_TCP_FLAG_URG
};

class diameter_ipfilter_rule_t 
{
  public:
  diameter_ipfilter_rule_t() : frag(false), established(false), setup(false)
  {}

  AAA_UINT8 action; 
  AAA_UINT8 dir; 
  AAA_UINT8 proto; 
  AAA_IPFILTER_RULE_SRCDST src, dst;

  bool frag; /* indicates fragmented packets except for the first
                fragment */
  std::list<int> ipOptionList; 
  std::list<int> tcpOptionList; 
  bool established; 
  bool setup; 
  std::list<int> tcpFlagList; 
  std::list<AAA_UINT8_RANGE> icmpTypeRangeList; 
} ;

enum {
  AAA_IPFILTER_RULE_ACTION_PERMIT,
  AAA_IPFILTER_RULE_ACTION_DENY 
};

enum {
  AAA_IPFILTER_RULE_DIRECTION_IN,
  AAA_IPFILTER_RULE_DIRECTION_OUT 
};

typedef diameter_octetstring_t avp_t;

enum {
  TRANSPORT_PROTO_TCP = 0,
  TRANSPORT_PROTO_SCTP,
  TRANSPORT_PROTO_UDP,
};

enum {
  AAA_PROTO_DIAMETER = 0,
  AAA_PROTO_RADIUS,
  AAA_PROTO_TACACSPLUS,
};

enum {
  AAA_SCHEME_AAA = 0,
  AAA_SCHEME_AAAS
};

enum {
  AUTH_REQUEST_TYPE_AUTHENTICATION_ONLY = 1,
  AUTH_REQUEST_TYPE_AUTHORIZE_ONLY = 2,
  AUTH_REQUEST_TYPE_AUTHORIZE_AUTHENTICATE = 3
};

#define DIAMETER_DEFAULT_PORT 10001

enum  {
  NORMAL  = 0,   
  BUG = 1,       
};
  
enum {
  MISSING_CONTAINER = 1,
  TOO_MUCH_AVP_ENTRIES,
  TOO_LESS_AVP_ENTRIES,
  PROHIBITED_CONTAINER,
  INVALID_CONTAINER_PARAM,
  INVALID_CONTAINER_CONTENTS,
  UNSUPPORTED_FUNCTIONALITY,
  INVALID_PARSER_USAGE,
  MISSING_AVP_DICTIONARY_ENTRY,
  MISSING_AVP_VALUE_PARSER
};

typedef enum {
    AAA_ADDRESS_RESERVED = 0,  
    AAA_ADDRESS_IP,   // IP (IP version 4)
    AAA_ADDRESS_IP6,  // IP6 (IP version 6)
    AAA_ADDRESS_NSAP, // NSAP
    AAA_ADDRESS_HDLC, // (8-bit multidrop)
    AAA_ADDRESS_BBN,  // 1822
    AAA_ADDRESS_802,  // 802 (includes all 802 media plus Ethernet "canonical format")
    AAA_ADDRESS_E163, // E.163   
    AAA_ADDRESS_E164, // E.164 (SMDS, Frame Relay, ATM)
    AAA_ADDRESS_F69,  // F.69 (Telex)
    AAA_ADDRESS_X121, // (X.25, Frame Relay)
    AAA_ADDRESS_IPX,  // IPX
    AAA_ADDRESS_ATALK, // Appletalk
    AAA_ADDRESS_DECIV, // Decnet IV
    AAA_ADDRESS_BVINE, // Banyan Vines
    AAA_ADDRESS_E164N, // E.164 with NSAP format subaddress
    AAA_ADDRESS_DNS,   // DNS (Domain Name System)
    AAA_ADDRESS_DN,    // Distinguished Name
    AAA_ADDRESS_ASN,   // AS Number
    AAA_ADDRESS_XTPV4, // XTP over IP version 4 
    AAA_ADDRESS_XTPV6, // XTP over IP version 6
    AAA_ADDRESS_XTP,   // native mode XTP
    AAA_ADDRESS_FCP,   // Fibre Channel World-Wide Port Name
    AAA_ADDRESS_FCN,   // Fibre Channel World-Wide Node Name
    AAA_ADDRESS_GWID,  // GWID
    AAA_ADDRESS_RESERVED2 = 65535
} AAA_ADDRESS;


class DIAMETERPARSER_EXPORT AAAErrorStatus
{
   private:
      int type;     
      int code;     
      std::string avp;   
   public:
      AAAErrorStatus(void) {
         type = NORMAL;
         code = DIAMETER_SUCCESS;
      };

      void get(int &type, int &code, std::string &avp);

      void get(int &type, int &code);

      void set(int type, int code);

      void set(int type, int code, AAADictionaryEntry* data);
};

typedef ACE_Malloc<ACE_LOCAL_MEMORY_POOL, ACE_SYNCH_MUTEX> AAAMalloc;
typedef ACE_Allocator_Adapter<AAAMalloc> AAAAllocator;

#define AAA_MEMORY_MANAGER_NAME "AAA_Memory_Manager"

class DIAMETERPARSER_EXPORT AAAMemoryManager : public AAAAllocator
{
  friend class ACE_Singleton<AAAMemoryManager, ACE_Recursive_Thread_Mutex>; 
 private:
  AAAMemoryManager() : AAAAllocator(AAA_MEMORY_MANAGER_NAME) {}
};

typedef ACE_Singleton<AAAMemoryManager, ACE_Recursive_Thread_Mutex> AAAMemoryManager_S;
DIAMETERPARSER_SINGLETON_DECLARE(ACE_Singleton, AAAMemoryManager, ACE_Recursive_Thread_Mutex);

class AAAAvpContainerEntry
{
     friend class AAAAvpContainerEntryManager; 
     friend class AAAAvpContainer; 
  public:
    AAA_AVPDataType& dataType() { return this->type; }

    template <class T> inline T& dataRef(Type2Type<T>)
      {
        return *((T*)data);
      }

    template <class T> inline T* dataPtr(Type2Type<T>)
      {
        return (T*)data;
      }

  protected:
    AAAAvpContainerEntry(int type) : type((AAA_AVPDataType)type) {}

    ~AAAAvpContainerEntry() {}

    void* operator new(size_t s) 
    { return AAAMemoryManager_S::instance()->malloc(s); }

    void operator delete(void *p) 
    { AAAMemoryManager_S::instance()->free(p); }

    AAA_AVPDataType type; 
    void*           data; 
};


template <class T>
class AAATypeSpecificAvpContainerEntry 
: public AAAAvpContainerEntry
{
 public:
  AAATypeSpecificAvpContainerEntry(int type) : AAAAvpContainerEntry(type) 
    { 
      data = (new(AAAMemoryManager_S::instance()->malloc(sizeof(T))) T);
    }

  ~AAATypeSpecificAvpContainerEntry() 
    { 
      AAAMemoryManager_S::instance()->free(data);
    }

  inline T* dataPtr() const { return (T*)data; }

  inline T& dataRef() const { return *((T*)data); }

  void* operator new(size_t s) 
  { return AAAMemoryManager_S::instance()->malloc(s); }

  void operator delete(void *p) 
  { AAAMemoryManager_S::instance()->free(p); }

};


enum AAAAvpParseType {
  PARSE_TYPE_FIXED_HEAD = 0,
  PARSE_TYPE_FIXED_TAIL,
  PARSE_TYPE_REQUIRED, 
  PARSE_TYPE_OPTIONAL
};

class DIAMETERPARSER_EXPORT AAAAvpContainer 
: public std::vector<AAAAvpContainerEntry*>
{
      friend class AAAAvpContainerList; 
   public:
      AAAAvpContainer() : flag(false), parseType(PARSE_TYPE_OPTIONAL)
         {}

      ~AAAAvpContainer() {}

      inline void releaseEntries() 
        { for (unsigned i=0; i<size(); i++) { delete (*this)[i]; }}

      inline void add(AAAAvpContainerEntry* e) { resize(size()+1, e); }

      void remove(AAAAvpContainerEntry* e);

      inline const char* getAvpName() const { return avpName.c_str(); }

      inline void setAvpName(const char* name) 
      { 
        avpName = std::string(name);
      }

      void* operator new(size_t s) 
        { return AAAMemoryManager_S::instance()->malloc(s); }

      void operator delete(void *p) 
        { AAAMemoryManager_S::instance()->free(p); }

      inline AAAAvpParseType& ParseType() { return parseType; }

   protected:
      std::string avpName;        
      bool flag;  
      AAAAvpParseType parseType;  
};


class DIAMETERPARSER_EXPORT AAAAvpContainerList 
: public std::list<AAAAvpContainer*>
  
{
   public:
      AAAAvpContainerList() {}

      ~AAAAvpContainerList();

      inline void add(AAAAvpContainer* c) { push_back(c); }

      inline void prepend(AAAAvpContainer* c) { push_front(c); }

      void releaseContainers();

      AAAAvpContainer* search(const char* name);

      void* operator new(size_t s) 
        { return AAAMemoryManager_S::instance()->malloc(s); }

      void* operator new(size_t s, void*p) 
        { return p; }

      void operator delete(void *p) 
        { AAAMemoryManager_S::instance()->free(p); }

      void operator delete(void *p, void*q)
        { AAAMemoryManager_S::instance()->free(p); }    

      AAAAvpContainer* search(AAADictionaryEntry*);
      void reset(); 
 private:
      AAAAvpContainer* search(const char*, bool);  
      AAAAvpContainer* search(bool);         
};

class DIAMETERPARSER_EXPORT AAAAvpContainerEntryManager
{
   public:
      AAAAvpContainerEntry *acquire(AAA_AVPDataType type);

      inline void release(AAAAvpContainerEntry* entry) { delete entry; }
};

class DIAMETERPARSER_EXPORT AAAAvpContainerManager
{
   public:
      AAAAvpContainer *acquire(const char* name);

      void release(AAAAvpContainer* entry);
};

struct hdr_flag {
  AAA_UINT8 r:1;  
  AAA_UINT8 p:1;  
  AAA_UINT8 e:1;  
  AAA_UINT8 t:1;  
  AAA_UINT8 rsvd:4; 
};

typedef bool boolean_t;

class AAADictionaryHandle {};

class DIAMETERPARSER_EXPORT AAADictionaryManager
{
   public:
      AAADictionaryManager(int p=-1) : protocol(p) { }
    
      void init(char *dictFile);

      boolean_t getCommandCode(char *commandName,
                               AAACommandCode *commandCode,
                               AAAApplicationId *appId);

      AAADictionaryHandle *getDictHandle(AAACommandCode code, 
                                         AAAApplicationId id,
                                         int rflag);

      AAADictionaryHandle *getDictHandle(char *cmdName);
    
   private:
      int protocol;
};

class AAAEmptyClass {};

template <class RAWDATA, class APPDATA, class DICTDATA = AAAEmptyClass>
class DIAMETERPARSER_EXPORT_ONLY AAAParser
{
   public:
      AAAParser() {}

      virtual ~AAAParser() {};

      virtual void parseRawToApp();

      virtual void parseAppToRaw();

      void setRawData(RAWDATA data) { rawData = data; }

      void setAppData(APPDATA data) { appData = data; }

      void setDictData(DICTDATA data) { dictData = data; }

      RAWDATA getRawData() { return rawData; }

      template <class T> void getRawData(T*& data) { data = (T*)rawData; }

      APPDATA getAppData() { return appData; }

      template <class T> void getAppData(T*& data) { data = (T*)appData; }

      DICTDATA getDictData() { return dictData; }

      template <class T> void getDictData(T*& data) { data = (T*)dictData; }

   private:
      RAWDATA rawData;   
      APPDATA appData;   
      DICTDATA dictData;  
};

enum DiameterParserError {
  DictionaryError,
  HeaderError,
  PayloadError
};

class AAAMessageBlock: public ACE_Message_Block
{
   public:
      static AAAMessageBlock* Acquire(char *buf, ACE_UINT32 s) { return new AAAMessageBlock(buf,s); }

      static AAAMessageBlock* Acquire(ACE_UINT32 s) { return new AAAMessageBlock(s); }

      static AAAMessageBlock* Acquire(AAAMessageBlock* b) { return new AAAMessageBlock(b); }

      void Release() { release(); }

  protected:
      AAAMessageBlock(char *buf, ACE_UINT32 s) { init(buf, s); }

      AAAMessageBlock(ACE_UINT32 s) { init(s); }

      AAAMessageBlock(AAAMessageBlock *b) : ACE_Message_Block((const ACE_Message_Block&)*b,0) {}

      void* operator new(size_t s) 
      { return AAAMemoryManager_S::instance()->malloc(s); }

      void operator delete(void *p) 
      { AAAMemoryManager_S::instance()->free(p); }

private:
      ~AAAMessageBlock() {}
};

class AAA_MessageBlockScope
{
    public:
       AAA_MessageBlockScope(ACE_Message_Block *&mb) : mb_(mb) { }
       ~AAA_MessageBlockScope(void) { mb_->release(); }

    protected:
       ACE_Message_Block *&mb_;
};

enum ParseOption {
  PARSE_LOOSE = 0,
  PARSE_STRICT = 1,
};

class AAADictionaryOption
{
public:
    AAADictionaryOption() {}
    AAADictionaryOption(ParseOption opt, int id) :
        option(opt), protocolId(id) {}
    
    ParseOption option;
    int protocolId;
};

class AAADiameterHeader;
class AAAMessage;

typedef AAAParser<AAAMessageBlock*, AAADiameterHeader*, ParseOption>
HeaderParser;

typedef AAAParser<AAAMessageBlock*, AAADiameterHeader*, AAADictionaryOption*>
HeaderParserWithProtocol;

typedef AAAParser<AAAMessageBlock*, AAAAvpContainerList*, AAADictionaryHandle*>
PayloadParser;

void DIAMETERPARSER_EXPORT_ONLY HeaderParser::parseRawToApp();// throw(AAAErrorStatus);

void DIAMETERPARSER_EXPORT_ONLY HeaderParser::parseAppToRaw();// throw(AAAErrorStatus);

void DIAMETERPARSER_EXPORT_ONLY PayloadParser::parseRawToApp();// throw(AAAErrorStatus);

void DIAMETERPARSER_EXPORT_ONLY PayloadParser::parseAppToRaw();// throw(AAAErrorStatus);

#define HEADER_SIZE 20

class DIAMETERPARSER_EXPORT AAADiameterHeader
{
      friend class AAAParser<AAAMessageBlock*, AAADiameterHeader*, ParseOption>; 
      friend class AAAParser<AAAMessageBlock*, AAADiameterHeader*, AAADictionaryOption*>; 
   public:
      AAADiameterHeader(AAA_UINT8 ver, 
                        ACE_UINT32 length, 
                        struct hdr_flag flags, 
                        AAACommandCode code, 
                        AAAApplicationId appId, 
                        ACE_UINT32 hh, 
                        ACE_UINT32 ee) {
          this->ver = ver; 
          this->length = length; 
          this->flags = flags;
          this->code = code; 
          this->appId = appId; 
          this->hh = hh;
          this->ee = ee;
      }

      AAADiameterHeader() {}

      inline AAADictionaryHandle *getDictHandle() { return dictHandle; }

      const char* getCommandName();

      AAA_UINT8 ver; 
      ACE_UINT32 length:24; 
      struct hdr_flag flags; 
      AAACommandCode code:24; 
      AAAApplicationId appId; 
      ACE_UINT32 hh; 
      ACE_UINT32 ee; 
 private:
      AAADictionaryHandle* dictHandle;
};

class DIAMETERPARSER_EXPORT AAAMessage
{
   public:
      AAADiameterHeader hdr; 
      AAAAvpContainerList acl; 
      AAAErrorStatus status; 
      IP_ADDR originator; 
      IP_ADDR sender; 
      time_t secondsTillExpire; 
      time_t startTime; 
};

typedef AAAParser<AAAMessageBlock*, AAAAvpContainerEntry*, 
                  AAADictionaryEntry*> AvpValueParser;

void DIAMETERPARSER_EXPORT_ONLY AvpValueParser::parseRawToApp();// throw(AAAErrorStatus);

void DIAMETERPARSER_EXPORT_ONLY AvpValueParser::parseAppToRaw();// throw(AAAErrorStatus);

typedef boost::function1<AAAAvpContainerEntry*, int> AvpContainerEntryFunctor;

typedef boost::function0<AvpValueParser*> AvpValueParserFunctor;

template <class T>
class AvpContainerEntryCreator 
{
 public:
  AAAAvpContainerEntry* operator()(int type) { return new T(type); }
};

template <class T>
class AvpValueParserCreator
{
 public:
  AvpValueParser* operator()() { return new T(); }
};

class DIAMETERPARSER_EXPORT AvpType {
 public:

  AvpType(char* name, AAA_AVPDataType type, ACE_UINT32 size,
          AvpValueParserFunctor parserCreator,
          AvpContainerEntryFunctor containerEntryCreator) :
    name(name), type(type), size(size),
    parserCreator(parserCreator),
    containerEntryCreator(containerEntryCreator) {}

  char* getName(void) { return name; };

  AAA_AVPDataType getType(void) { return type; };

  ACE_UINT32 getMinSize(void) { return size; };

  AvpValueParser* createParser() { return parserCreator(); }

    AAAAvpContainerEntry* createContainerEntry(int type) 
    { return containerEntryCreator(type); }

 private:

    char *name; 
    AAA_AVPDataType type; 
    ACE_UINT32 size;  
    AvpValueParserFunctor parserCreator; 
    AvpContainerEntryFunctor containerEntryCreator; 
};

class DIAMETERPARSER_EXPORT AvpTypeList_S : public std::list<AvpType*> 
{
  friend class ACE_Singleton<AvpTypeList_S, ACE_Recursive_Thread_Mutex>; 
 public:
  AvpType* search(ACE_UINT32 type) 
    {
      for (iterator i = begin(); i != end(); i++)
        {
          if ((ACE_UINT32)((*i)->getType()) == type)
            return *i;
        }
      return NULL;
    }
  AvpType* search(const char* name)
    {
      for (iterator i = begin(); i != end(); i++)
        {
          if (ACE_OS::strcmp((*i)->getName(), name) == 0)
            return *i;
        }
      return NULL;
    }
  void add(AvpType* avpType) {
    mutex.acquire(); 
    push_back(avpType); 
    mutex.release();
  }
 private:
  AvpTypeList_S(void) { registerDefaultTypes(); };

  ~AvpTypeList_S(void) {};

  void registerDefaultTypes();

  ACE_Thread_Mutex mutex; 
};

typedef ACE_Singleton<AvpTypeList_S, ACE_Recursive_Thread_Mutex> AvpTypeList;
DIAMETERPARSER_SINGLETON_DECLARE(ACE_Singleton, AvpTypeList_S, ACE_Recursive_Thread_Mutex);

class UTF8Checker
{
 public:
  UTF8Checker() {}

  int operator()(const char *data, unsigned length, bool nullCheck=false)
  {
    unsigned i = 0;
    while (i<length)
      {
        unsigned char b = data[i++];
      
        // Check the first octet of the current UTF8 character.
        // Null check
        if (b == 0x00) { if (nullCheck) return -1; }
        // The first bit check.
        else if ((b >> 7) == 0x00) { continue; }  // 7-bit ASCII character.

        // If the first 7 bits are all '1's, this is not an UTF8 character.
        if ((b >> 1) == 0x76) { return -1; } // Out of UTF8 character range.

        b <<= 1;
        // Count the number of '1' of the first octet
        int count=0;
        for (count=0; count<5; count++) { if ((b && 0x40) == 0) break; }
        
        // The count value must be greater than 0.
        if (count==0) { return -1; } // Out of UTF8 character range.

        // Check remaining octet(s)
        for (int j=0; j<count; j++) { 
          if (i >= length) { return -1; }
          if ((data[i++] >> 6) != 0x02) { return -1; }
        }
      }
    return 0;
  }
};

class AAALogMsg : public ACE_Log_Msg
{
       friend class ACE_Singleton<AAALogMsg, ACE_Recursive_Thread_Mutex>;    
    private:
        /* 
         * protected constructors/destructors to prevent derivation
         */
        AAALogMsg() { }
        ~AAALogMsg() { }
};

typedef ACE_Singleton<AAALogMsg, ACE_Recursive_Thread_Mutex> AAALogMsg_S;
DIAMETERPARSER_SINGLETON_DECLARE(ACE_Singleton, AAALogMsg, ACE_Recursive_Thread_Mutex);

#define AAA_LOG AAALogMsg_S::instance()->log

template <typename T>
class AAA_ScholarAttribute
{
 public:
  AAA_ScholarAttribute() : isSet(false) {}
  AAA_ScholarAttribute(T &val) : value(val), isSet(true) {}
  virtual ~AAA_ScholarAttribute() {}
  inline void Clear() { isSet = false; }
  inline void Set(T val) { value=val; isSet=true; }
  virtual void CopyFrom(AAAAvpContainer &c) 
  { 
    value=c[0]->dataRef(Type2Type<T>()); isSet=true; 
  }
  void CopyTo(AAAAvpContainer &c, AAA_AVPDataType t) 
  {
    AAAAvpContainerEntryManager em;
    AAAAvpContainerEntry *e = em.acquire(t);
    e->dataRef(Type2Type<T>()) = value;
    c.add(e);
  }
  inline bool operator==(const T& v) const { return value == v; }
  inline T& operator()() { return value; }
  inline T& operator=(T v) { isSet = true; value=v; return value; }
  inline bool& IsSet() { return isSet; }

 protected:
  T value;
  bool isSet;
};

template <typename T>
class AAA_GroupedScholarAttribute : public AAA_ScholarAttribute<T>
{
public:
  void CopyFrom(AAAAvpContainer &c)
  {
      AAAAvpContainerList& cl = 
        c[0]->dataRef(Type2Type<AAAAvpContainerList>());
      value.CopyFrom(cl);
      isSet = true;
  }
  void CopyTo(AAAAvpContainer &c)
  {
    AAAAvpContainerEntryManager em;
    AAAAvpContainerEntry *e = em.acquire(AAA_AVP_GROUPED_TYPE);
    value.CopyTo(e->dataRef(Type2Type<AAAAvpContainerList>()));
    c.add(e);
  }
  inline T& operator=(T v) { isSet = true; value=v; return value; }
};

template <typename T>
class AAA_VectorAttribute : public std::vector<T>
{
 public:
  AAA_VectorAttribute() : isSet(false) {}
  virtual ~AAA_VectorAttribute() {}
  inline void Clear() { isSet = false; std::vector<T>::clear(); }
  inline std::vector<T>& operator()() { return *this; }
  inline std::vector<T>& operator=(std::vector<T>& value) 
  { 
    isSet = true; 
    (std::vector<T>&)(*this)=value; 
        return *this; 
  }
  virtual void CopyFrom(AAAAvpContainer &c) 
  { 
    isSet = true; 
    if (size() < c.size())
      resize(c.size());
    for (unsigned i=0; i<c.size(); i++)
      (*this)[i] = c[i]->dataRef(Type2Type<T>());
  }
  void CopyTo(AAAAvpContainer &c, AAA_AVPDataType t) 
  {
    AAAAvpContainerEntryManager em;
    AAAAvpContainerEntry *e = em.acquire(t);
    for (unsigned i=0; i<size(); i++)
      {
        e = em.acquire(t);
        e->dataRef(Type2Type<T>()) = (*this)[i];
        c.add(e);
      }
  }
  inline bool& IsSet() { return isSet; }

protected:
  bool isSet;
};

template <typename T>
class AAA_GroupedVectorAttribute : public AAA_VectorAttribute<T>
{
public:
  void CopyFrom(AAAAvpContainer &c)
  {
    isSet = true; 
    if (size() < c.size())
      resize(c.size());
    for (unsigned i=0; i<c.size(); i++)
      {
        AAAAvpContainerList& cl = 
          c[i]->dataRef(Type2Type<AAAAvpContainerList>());
        (*this)[i].CopyFrom(cl);
        isSet = true;
      }
  }
  void CopyTo(AAAAvpContainer &c)
  {
    AAAAvpContainerEntryManager em;
    AAAAvpContainerEntry *e;
    for (unsigned i=0; i<size(); i++)
      {
        e = em.acquire(AAA_AVP_GROUPED_TYPE);
        (*this)[i].CopyTo(e->dataRef(Type2Type<AAAAvpContainerList>()));
        e->dataRef(Type2Type<T>()) = (*this)[i];
        c.add(e);
      }
  }
  inline T& operator=(T v) { isSet = true; value=v; return value; }
};

template<class D, AAA_AVPDataType t>
class AAA_AvpWidget {
    public:
        AAA_AvpWidget(char *name) {
            AAAAvpContainerManager cm;
            m_cAvp = cm.acquire(name);
        }
        AAA_AvpWidget(char *name, D &value) {
            AAAAvpContainerManager cm;
            m_cAvp = cm.acquire(name);
            Get() = value;
        }
        AAA_AvpWidget(AAAAvpContainer *avp) :
            m_cAvp(avp) {
        }
        ~AAA_AvpWidget() {
            if (! m_cAvp->size()) {
                delete m_cAvp;
            }
        }
        D &Get() {
            AAAAvpContainerEntryManager em;
            AAAAvpContainerEntry *e = em.acquire(t);
            m_cAvp->add(e);            
            return e->dataRef(Type2Type<D>());
        }
        AAAAvpContainer *operator()() {
            return m_cAvp;
        }
        bool empty() {
            return (m_cAvp->size() == 0);
        }
    private:
        AAAAvpContainer *m_cAvp;
};

typedef AAA_AvpWidget<diameter_identity_t,
                      AAA_AVP_DIAMID_TYPE> AAA_IdentityAvpWidget;
typedef AAA_AvpWidget<diameter_address_t,
                      AAA_AVP_ADDRESS_TYPE> AAA_AddressAvpWidget;
typedef AAA_AvpWidget<diameter_integer32_t,
                      AAA_AVP_INTEGER32_TYPE> AAA_Int32AvpWidget;
typedef AAA_AvpWidget<diameter_unsigned32_t,
                      AAA_AVP_UINTEGER32_TYPE> AAA_UInt32AvpWidget;
typedef AAA_AvpWidget<diameter_utf8string_t,
                     AAA_AVP_UTF8_STRING_TYPE> AAA_Utf8AvpWidget;
typedef AAA_AvpWidget<diameter_grouped_t,
                     AAA_AVP_GROUPED_TYPE> AAA_GroupedAvpWidget;
typedef AAA_AvpWidget<diameter_octetstring_t,
                     AAA_AVP_STRING_TYPE> AAA_StringAvpWidget;
typedef AAA_AvpWidget<diameter_uri_t,
                     AAA_AVP_DIAMURI_TYPE> AAA_DiamUriAvpWidget;
typedef AAA_AvpWidget<diameter_enumerated_t,
                     AAA_AVP_ENUM_TYPE> AAA_EnumAvpWidget;

template<class D, AAA_AVPDataType t>
class AAA_AvpContainerWidget
{
    public:
       AAA_AvpContainerWidget(AAAAvpContainerList &lst) :
           m_List(lst) {
       }
       D *GetAvp(char *name, unsigned int index=0) {
          AAAAvpContainer* c = m_List.search(name);
          if (c && (index < c->size())) {
              AAAAvpContainerEntry *e = (*c)[index];
              return e->dataPtr(Type2Type<D>());
          }
          return (0);
       }
       D &AddAvp(char *name) {
          AAAAvpContainer* c = m_List.search(name);
          if (! c) {
              AAA_AvpWidget<D, t> avpWidget(name);
              m_List.add(avpWidget());
              return avpWidget.Get();
          }
          else if (c->size() == 0) {
              AAA_AvpWidget<D, t> avpWidget(c);
              m_List.add(avpWidget());
              return avpWidget.Get();
          }
          else {
              return (*c)[0]->dataRef(Type2Type<D>());
          }
       }
       void AddAvp(AAA_AvpContainerWidget<D, t> &avp) {
           m_List.add(avp());
       }
       void DelAvp(char *name) {
          std::list<AAAAvpContainer*>::iterator i;
          for (i=m_List.begin(); i!=m_List.end();i++) {
              AAAAvpContainer *c = *i;
              if (ACE_OS::strcmp(c->getAvpName(), name) == 0) {
                  m_List.erase(i);
                  AAAAvpContainerManager cm;
                  cm.release(c);
              }
          }
       }

    private:
       AAAAvpContainerList &m_List;
};

typedef AAA_AvpContainerWidget<diameter_identity_t, AAA_AVP_DIAMID_TYPE>
           AAA_IdentityAvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_address_t, AAA_AVP_ADDRESS_TYPE>
           AAA_AddressAvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_integer32_t, AAA_AVP_INTEGER32_TYPE>
           AAA_Int32AvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_unsigned32_t, AAA_AVP_UINTEGER32_TYPE>
           AAA_UInt32AvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_utf8string_t, AAA_AVP_UTF8_STRING_TYPE>
           AAA_Utf8AvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_grouped_t, AAA_AVP_GROUPED_TYPE>
           AAA_GroupedAvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_octetstring_t, AAA_AVP_STRING_TYPE>
           AAA_StringAvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_uri_t, AAA_AVP_DIAMURI_TYPE>
           AAA_DiamUriAvpContainerWidget;
typedef AAA_AvpContainerWidget<diameter_enumerated_t, AAA_AVP_ENUM_TYPE>
           AAA_EnumAvpContainerWidget;

class AAA_MsgResultCode
{
    public:
        typedef enum {
            RCODE_NON_PRESENT,
            RCODE_INFORMATIONAL,
            RCODE_SUCCESS,
            RCODE_PROTOCOL_ERROR,
            RCODE_TRANSIENT_FAILURE,
            RCODE_PERMANENT_FAILURE
       } RCODE;
    
    public:
       AAA_MsgResultCode(AAAMessage &msg) :
           m_Msg(msg) {
       }
       diameter_unsigned32_t ResultCode() {
           AAA_UInt32AvpContainerWidget resultCode(m_Msg.acl);
           diameter_unsigned32_t *rc = resultCode.GetAvp("Result-Code");
           return (rc) ? *rc : 0;
       }
       void ResultCode(diameter_unsigned32_t c) {
           AAA_UInt32AvpContainerWidget resultCode(m_Msg.acl);
           resultCode.AddAvp("Result-Code") = c;
       }
       RCODE InterpretedResultCode() {
           diameter_unsigned32_t code = ResultCode();
           if (code) {
               for (int i=RCODE_INFORMATIONAL;
                    i<=RCODE_PERMANENT_FAILURE;
                    i++) {
                   code -= 1000;
                   if ((code/1000) == 0) {
                       return RCODE(i);
                   }
               }
               return (RCODE_PERMANENT_FAILURE);
           }
           return (RCODE_NON_PRESENT);
       }
    
    private:
       AAAMessage &m_Msg;
};

#endif /* __DIAMETER_PARSER_API_H__ */

---