efd.h

Go to the documentation of this file.

/*
* Copyright (c) 2017 Sprint
* Copyright (c) 2019 Sprint
*
* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
 
#ifndef __EFD_H
#define __EFD_H
 
 
#include <stddef.h>
#include <string.h>
#include <arpa/inet.h>
#include <time.h>
 
#include <stdexcept>
#include <string>
#include <list>
#include <map>
 
#include "freeDiameter/freeDiameter-host.h"
#include "freeDiameter/libfdcore.h"
#include "freeDiameter/libfdproto.h"
 
#include "ebase.h"
#include "estring.h"
#include "etime.h"
#include "etimer.h"
#include "eutil.h"
 
class FDException : public std::runtime_error
{
public:
   FDException(const char *m) : std::runtime_error(m) {}
   FDException(const std::string &m) : std::runtime_error(m) {}
};
 
 
template<class T>
class FDBuffer
{
public:
   FDBuffer(size_t size) { msize = size; mbuf = new T[msize]; }
   ~FDBuffer() { if (mbuf) delete [] mbuf; }
   T *get() { return mbuf; }
private:
   FDBuffer();
   size_t msize;
   T *mbuf;
};
 
class FDDictionaryEntryApplication;
class FDDictionaryEntryVendor;
 
class FDEngine
{
public:
   FDEngine( const char *cfgfile = NULL );
   FDEngine( const std::string &cfgfile );
   ~FDEngine();
 
   Bool init();
   Bool start();
   Void uninit( Bool wait = true );
   Void waitForShutdown();
 
   const EString &getConfigFile() { return m_cfgfile; }
   const EString &setConfigFile( const char *cf ) { return m_cfgfile = cf; }
   const EString &setConfigFile( const std::string &cf ) { return setConfigFile( cf.c_str() ); }
 
   Void advertiseSupport( FDDictionaryEntryApplication &app, Int auth = 0, Int acct = 0 );
   Void advertiseSupport( FDDictionaryEntryApplication &app, FDDictionaryEntryVendor &vendor, Int auth=0, Int acct=0 );
private:
   EString m_cfgfile;
};
 
 
class FDDictionaryEntry
{
public:
   struct dictionary *getDictionary() const { return m_dict; }
   struct dict_object *getEntry() const { return m_de; }
   Bool isValid() { return m_de != NULL; }
 
protected:
   FDDictionaryEntry();
   FDDictionaryEntry( const Void *what, enum dict_object_type type, Int criteria, struct dictionary *dict = NULL );
 
   Void init( const Void *what, enum dict_object_type type, Int criteria, struct dictionary *dict = NULL );
   Void init( struct dict_object *de, struct dictionary *dict = NULL );
 
   virtual ~FDDictionaryEntry();
 
private:
 
   struct dictionary *m_dict;
   struct dict_object *m_de;
   Bool m_destroy;
};
 
 
class FDDictionaryEntryApplication : public FDDictionaryEntry
{
public:
 
   FDDictionaryEntryApplication( const char *name, struct dictionary *dict = NULL );
 
   const char *getName() const { return m_data.application_name; }
   application_id_t getId() const { return m_data.application_id; }
 
private:
   Bool init();
 
   dict_application_data m_data;
};
 
 
class FDDictionaryEntryVendor : public FDDictionaryEntry
{
public:
   FDDictionaryEntryVendor( const char *name, struct dictionary *dict = NULL );
   FDDictionaryEntryVendor( vendor_id_t vendorid, struct dictionary *dict = NULL );
   FDDictionaryEntryVendor( const FDDictionaryEntryApplication &app, struct dictionary *dict = NULL );
 
   const char *getName() { return m_data.vendor_name; }
   vendor_id_t getId() { return m_data.vendor_id; }
 
private:
   Bool init();
 
   dict_vendor_data m_data;
};
 
 
enum DiameterDataType
{
   DDTUnknown,
   DDTOctetString,
   DDTI32,
   DDTI64,
   DDTU32,
   DDTU64,
   DDTF32,
   DDTF64,
   DDTGrouped,
   DDTAddress,
   DDTTime,
   DDTUTF8String,
   DDTDiameterIdentity,
   DDTDiameterURI,
   DDTEnumerated,
   DDTIPFilterRule
};
 
class FDDictionaryEntryAVP : public FDDictionaryEntry
{
public:
   FDDictionaryEntryAVP( const char *name, Bool allVendors = false, struct dictionary *dict = NULL );
   FDDictionaryEntryAVP( const char *name, vendor_id_t vendorid, struct dictionary *dict = NULL );
   FDDictionaryEntryAVP( struct dict_object *de );
 
   Bool isDerived() const { return m_isderived; }
 
   const char *getName() const { return m_basedata.avp_name; }
   vendor_id_t getVendorId() const { return m_basedata.avp_vendor; }
   avp_code_t getAvpCode() const { return m_basedata.avp_code; }
   DiameterDataType getDataType() const { return m_datatype; }
 
private:
   Void getTypeInfo();
   
   std::string m_name;
   vendor_id_t m_vendorid;
   
   struct dict_avp_data m_basedata;
   struct dict_object *m_derivedtype;
   struct dict_type_data m_derivedtypedata;
 
   Bool m_isderived;
   DiameterDataType m_datatype;
};
 
 
class FDDictionaryEntryCommand : public FDDictionaryEntry
{
public:
   FDDictionaryEntryCommand( const char *name, struct dictionary *dict = NULL );
   FDDictionaryEntryCommand( command_code_t cmdid, struct dictionary *dict = NULL );
   FDDictionaryEntryCommand( const FDDictionaryEntryCommand &req, struct dictionary *dict = NULL );
 
   Bool isRequest() const { return ( m_data.cmd_flag_val & CMD_FLAG_REQUEST ) ? true : false; } 
   Bool isAnswer() const { return ( m_data.cmd_flag_val & CMD_FLAG_REQUEST ) ? false : true; } 
 
   command_code_t getCommandCode() { return m_data.cmd_code; }
   const char *getName() { return m_data.cmd_name; }
 
private:
   struct dict_cmd_data m_data;
};
 
 
class FDMessage;
class FDExtractor;
class FDExtractorList;
class FDExtractorAvp;
class FDExtractorAvpList;
 
class FDAvp
{
   friend FDMessage;
 
public:
   FDAvp( FDDictionaryEntryAVP &de, Bool dedel = false );
   FDAvp( FDDictionaryEntryAVP &de, struct avp *a, Bool dedel = false );
 
   ~FDAvp();
 
   FDAvp &add( FDAvp &avp );
 
   Bool isValid() { return m_avp != NULL; }
 
   FDAvp &add( FDDictionaryEntryAVP &de, int32_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, int64_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, uint32_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, uint64_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, float v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, double v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, const char *v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, const std::string &v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, const char *v, size_t len ) { FDAvp avp( de ); avp.set( v, len ); return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, const uint8_t *v, size_t len ) { FDAvp avp( de ); avp.set( v, len ); return add( avp ); }
   FDAvp &add( FDDictionaryEntryAVP &de, const ETime &v ) { FDAvp avp( de ); avp = v; return add( avp ); }
 
   FDAvp &operator=( int32_t v )              { return set( v ); }
   FDAvp &operator=( int64_t v )              { return set( v ); }
   FDAvp &operator=( uint32_t v )             { return set( v ); }
   FDAvp &operator=( uint64_t v )             { return set( v ); }
   FDAvp &operator=( float v )                { return set( v ); }
   FDAvp &operator=( double v )               { return set( v ); }
   FDAvp &operator=( const char *v )          { return set( v ); }
   FDAvp &operator=( const std::string &v )   { return set( v ); }
   FDAvp &operator=( const ETime &v )         { return set( v ); }
 
   Bool get( int32_t &v )                    { if ( m_avphdr == NULL ) return false; v = m_avphdr->avp_value->i32; return true; }
   Bool get( uint32_t &v )                   { if ( m_avphdr == NULL ) return false; v = m_avphdr->avp_value->u32; return true; }
   Bool get( uint64_t &v )                   { if ( m_avphdr == NULL ) return false; v = m_avphdr->avp_value->u64; return true; }
   Bool get( float &v )                      { if ( m_avphdr == NULL ) return false; v = m_avphdr->avp_value->f32; return true; }
   Bool get( double &v )                     { if ( m_avphdr == NULL ) return false; v = m_avphdr->avp_value->f64; return true; }
   Bool get( int64_t &v );
   Bool get( std::string &v );
   Bool get( char *data, size_t &len );
   Bool get( uint8_t *data, size_t &len );
   Bool get( sSS &ss );
   Bool get( ETime &v );
 
   FDAvp &set( int32_t v )                    { m_value.i32 = v; assignValue(); return *this; }
   FDAvp &set( uint32_t v )                   { m_value.u32 = v; assignValue(); return *this; }
   FDAvp &set( uint64_t v )                   { m_value.u64 = v; assignValue(); return *this; }
   FDAvp &set( float v )                      { m_value.f32 = v; assignValue(); return *this; }
   FDAvp &set( double v )                     { m_value.f64 = v; assignValue(); return *this; }
   FDAvp &set( const char *v )                { return set( v, strlen( v ) ); }
   FDAvp &set( const uint8_t *v, size_t len ) { m_value.os.data = (uint8_t*)v; m_value.os.len = len; assignValue(); return *this; }
   FDAvp &set( const std::string &v )         { return set( v.c_str(), v.size() ); }
   FDAvp &set( int64_t v );
   FDAvp &set( const char *v, size_t len );
   FDAvp &set( const ETime& v );
 
   FDAvp getNext( Bool &found );
   FDAvp getChild( Bool &found );
 
   struct avp *getAvp() { return m_avp; }
   union avp_value *getAvpValue() { return &m_value; }
   FDAvp &setAvp( struct avp *a );
 
   FDAvp &add( FDExtractor &e );
   FDAvp &add( FDExtractorList &el );
   FDAvp &add( FDExtractorAvp &ea );
   FDAvp &add( FDExtractorAvpList &eal );
 
   FDAvp &addJson( const char *json );
   FDAvp &addJson( const std::string &json ) { return addJson( json.c_str() ); }
   Bool getJson( std::string &json );
 
   Void dump();
 
   FDDictionaryEntryAVP &getDictionaryEntry() { return *m_de; }
 
protected:
   Void addTo( msg_or_avp *reference );
 
private:
   Void init();
   Void assignValue();
 
   FDDictionaryEntryAVP *m_de;
   FDBuffer<uint8_t> *m_buf;
   Bool m_assigned;
   struct avp *m_avp;
   struct avp_hdr *m_avphdr;
   Bool m_dedel;
   union avp_value m_value;
};
 
class FDMessageRequest;
class FDMessageAnswer;
 
class FDMessage
{
public:
   FDDictionaryEntryCommand *getCommand() { return m_de; }
 
   FDMessage &add( FDAvp &avp ) { avp.addTo( m_msg ); return *this; }
   FDMessage &add( FDDictionaryEntryAVP &de, int32_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, int64_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, uint32_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, uint64_t v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, float v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, double v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, const char *v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, const std::string &v ) { FDAvp avp( de ); avp = v; return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, const char *v, size_t len ) { FDAvp avp( de ); avp.set( v, len ); return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, const uint8_t *v, size_t len ) { FDAvp avp( de ); avp.set( v, len ); return add( avp ); }
   FDMessage &add( FDDictionaryEntryAVP &de, const ETime &v ) { FDAvp avp( de ); avp = v; return add( avp ); }
 
   FDMessage &add( FDExtractor &e );
   FDMessage &add( FDExtractorList &el );
   FDMessage &add( FDExtractorAvp &ea );
   FDMessage &add( FDExtractorAvpList &eal );
 
   Bool get( FDDictionaryEntryAVP &de, int32_t &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, int64_t &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, uint32_t &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, uint64_t &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, float &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, double &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, std::string &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
   Bool get( FDDictionaryEntryAVP &de, char *v, size_t &len ) { FDAvp avp = findAVP( de ); return avp.get( v, len ); }
   Bool get( FDDictionaryEntryAVP &de, uint8_t *v, size_t &len ) { FDAvp avp = findAVP( de ); return avp.get( v, len ); }
   Bool get( FDDictionaryEntryAVP &de, ETime &v ) { FDAvp avp = findAVP( de ); return avp.get( v ); }
 
   FDAvp findAVP( FDDictionaryEntryAVP &de );
   FDAvp getFirstAVP( Bool &found );
 
   Void dump();
 
   Bool isRequest() { return m_de->isRequest(); }
   Bool isAnswer() { return m_de->isAnswer(); }
 
   struct msg *getMsg() { return m_msg; }
 
   Void addOrigin();
 
   FDMessage &addJson( const char *json );
   FDMessage &addJson( const std::string &json ) { return addJson( json.c_str() ); }
   Bool getJson( std::string &json );
 
protected:
   FDMessage( Bool req2ans, FDDictionaryEntryCommand *de, struct msg *pmsg = NULL, Bool dedel = false, Bool msgdel = true );
   FDMessage( FDDictionaryEntryCommand *de, struct msg *pmsg = NULL, Bool dedel = false );
   FDMessage( FDDictionaryEntryApplication *ade, FDDictionaryEntryCommand *cde, struct msg *pmsg = NULL, Bool dedel = false );
   ~FDMessage();
 
   FDMessage &sendRequest( Void (*anscb)(Void*,struct msg**), FDMessageRequest &req );
   FDMessage &sendAnswer();
   
   Void setMsgDelete( Bool v ) { m_msgdel = v; }
 
private:
   FDMessage();
 
   FDDictionaryEntryCommand *m_de;
   struct msg *m_msg;
   Bool m_dedel;
   Bool m_msgdel;
   struct dict_cmd_data m_basedata;
};
 
class FDMessageAnswer : public FDMessage
{
   friend FDMessageRequest;
 
public:
   FDMessageAnswer( FDMessageRequest *req, struct msg *pmsg ); // used to encapsulate a FD answer message
   FDMessageAnswer( FDMessageRequest *req ); // used to create and encapsulate a FD answer from a request
   ~FDMessageAnswer();
 
   FDMessageAnswer &send();
 
private:
   FDMessageRequest *m_request;
};
 
class FDMessageRequest : public FDMessage
{
   friend FDMessageAnswer;
 
public:
   FDMessageRequest( FDDictionaryEntryCommand *cde );
   FDMessageRequest( FDDictionaryEntryCommand *cde, struct msg *pmsg );
   FDMessageRequest( FDDictionaryEntryApplication *ade, FDDictionaryEntryCommand *cde );
   virtual ~FDMessageRequest();
 
   FDMessageRequest &send();
 
   virtual Void processAnswer( FDMessageAnswer &ans );
 
   Bool setPreserveAnswer(Bool preserve) { return m_preserve_answer = preserve; }
   Bool getPreserveAnswer() { return m_preserve_answer; }
 
protected:
   ETimer m_timer;
 
private:
   static Void anscb( Void * data, struct msg ** pmsg );
 
   Bool m_preserve_answer;
};
 
class FDCommand
{
public:
   FDDictionaryEntryCommand &getDictionaryEntry() { return m_de; }
 
   virtual Bool isRequest() = 0;
   Bool isAnswer() { return !isRequest(); }
 
protected:
   FDCommand( FDDictionaryEntryCommand &de );
 
private:
   FDCommand();
 
   FDDictionaryEntryCommand &m_de;
};
 
class FDCommandRequest : public FDCommand
{
public:
   FDCommandRequest( FDDictionaryEntryCommand &de );
 
   Bool isRequest() { return true; }
 
   virtual Int process( FDMessageRequest *req ) = 0;
};
 
#define FDISREQUEST(hdr) ((hdr->msg_flags & CMD_FLAG_REQUEST) == CMD_FLAG_REQUEST)
#define FDISANSWER(hdr) ((hdr->msg_flags & CMD_FLAG_REQUEST) != CMD_FLAG_REQUEST)
 
class FDApplication
{
public:
   FDApplication( FDDictionaryEntryApplication *de );
   ~FDApplication();
 
   FDDictionaryEntryApplication &getDictionaryEntry() { return *m_de; }
 
   FDApplication &registerHandler( FDCommandRequest &cmd );
 
protected:
   FDApplication() : m_de( NULL ) {}
   FDDictionaryEntryApplication *setDictionaryEntry( FDDictionaryEntryApplication *de ) { return m_de = de; }
 
private:
 
   static Int commandcb( struct msg **m, struct avp *avp, struct session *session, Void *data, enum disp_action *action );
 
   FDDictionaryEntryApplication *m_de;
   std::list<FDCommandRequest*> m_cmds;
};
 
 
class FDSession
{
public:
   FDSession();
   ~FDSession();
 
   const EString &getSessionId();
   Void addSessionId( FDMessage &msg, FDDictionaryEntryAVP &deSessionId );
 
private:
   Void init();
 
   struct session *m_session;
   EString m_sid;
};
 
 
enum FDPeerState
{
   PSInvalid = -1,
   PSNew = 0,
   PSOpen,
   PSClosed,
   PSClosing,
   PSWaitCnxAck,
   PSWaitCnxAckElec,
   PSWaitCEA,
   PSOpenHandshake,
   PSSuspect,
   PSReOpen,
   PSOpenNew,
   PSClosingGrace,
   PSZombie
};
 
class FDPeer
{
public:
   FDPeer();
   FDPeer( DiamId_t diamid, uint16_t port = 3868 );
   FDPeer( const std::string &diamid, uint16_t port = 3868 );
 
   const std::string &getDiameterId() { return m_diamid; }
   FDPeer &setDiameterId( DiamId_t diamid ) { m_diamid = diamid; return *this; }
 
   uint16_t getPort() { return m_port; }
   FDPeer &setPort( uint16_t v ) { m_port = v; return *this; }
 
   const EString &getDestinationHost() const { return m_diamid; }
   const EString &getDestinationRealm() const { return m_destrealm; }
 
   const EString &setDestinationIp( const char *ip ) { m_destip = ip; return getDestinationIp(); }
   const EString &setDestinationIp( const std::string &ip ) { m_destip = ip; return getDestinationIp(); }
   const EString &getDestinationIp() const { return m_destip; }
 
   FDPeerState getState();
 
   Bool isOpen() { return getState() == PSOpen; }
 
   Void add();
 
private:
   Void init();
   static Void peercb( struct peer_info *pi, Void *data );
 
   EString m_diamid;
   EString m_destrealm;
   EString m_destip;
   uint16_t m_port;
   struct peer_hdr *m_peer;
};
 
class FDPeerList : public std::list<FDPeer*>
{
public:
   FDPeerList();
   ~FDPeerList();
 
   Bool isPeerOpen();
 
   FDPeer *getOpenPeer();
};
 
 
class FDExtractorAvp;
 
enum eFDExtractorType
{
   etAvp,
   etAvpList,
   etExtractor,
   etExtractorList
};
 
class FDExtractorBase
{
public:
   FDExtractorBase( FDDictionaryEntryAVP *de )
      : m_de( de ),
        m_idx( -1 ),
        m_resolved( false )
   {
   }
 
   virtual ~FDExtractorBase()
   {
   }
 
   virtual eFDExtractorType getExtractorType() = 0;
 
   Int getIndex() { return m_idx; }
   Int setIndex( Int idx ) { return m_idx = idx; }
 
   Bool getResolved() { return m_resolved; }
   Bool setResolved( Bool resolved = true ) { return m_resolved = resolved; }
 
   Bool exists() { return m_idx != -1; }
 
   FDDictionaryEntryAVP *getDictionaryEntry() { return m_de; }
 
private:
   FDDictionaryEntryAVP *m_de;
   Int m_idx;
   Bool m_resolved;
};
 
class FDExtractorKey
{
public:
   FDExtractorKey()
      : m_vndid( 0 ),
        m_avpcode( 0 )
   {
   }
 
   FDExtractorKey( vendor_id_t v, avp_code_t a )
      : m_vndid( v ),
        m_avpcode( a )
   {
   }
 
   FDExtractorKey( const FDExtractorKey &k )
      : m_vndid( k.m_vndid ),
        m_avpcode( k.m_avpcode )
   {
   }
 
   virtual ~FDExtractorKey()
   {
   }
 
   Bool operator <(const FDExtractorKey &rval ) const
   {
      return
         m_vndid < rval.m_vndid ? True :
         m_vndid > rval.m_vndid ? False : m_avpcode < rval.m_avpcode;
   }
 
   vendor_id_t getVendor() { return m_vndid; }
   vendor_id_t setVendor( vendor_id_t v ) { return m_vndid = v; }
 
   avp_code_t getAvpCode() { return m_avpcode; }
   avp_code_t setAvpCode( avp_code_t a ) { return m_avpcode = a; }
 
private:
   vendor_id_t m_vndid;
   avp_code_t m_avpcode;
};
 
class FDExtractor : public FDExtractorBase
{
   friend FDExtractorList;
   friend FDExtractorAvp;
   friend FDExtractorAvpList;
 
public:
   FDExtractor();
   FDExtractor( FDMessage &msg );
   FDExtractor( FDDictionaryEntryCommand &de );
   FDExtractor( FDExtractor &parent, FDDictionaryEntryAVP &de );
   virtual ~FDExtractor();
 
   eFDExtractorType getExtractorType() { return etExtractor; }
 
   Void setReference( FDMessage &msg ) { m_reference = msg.getMsg(); }
   Void setReference( FDAvp &avp )     { m_reference = avp.getAvp(); }
   Void setReference( msg_or_avp *m )  { m_reference = m; }
 
   FDExtractor *getParent() { return m_parent; }
   msg_or_avp *getReference();
 
   Void add( FDExtractorBase &base );
 
   Bool exists( Bool skipResolve = false );
 
   Void dump();
 
   Bool getJson( std::string &json );
 
protected:
   Void resolve();
 
private:
   FDExtractor *m_parent;
   msg_or_avp *m_reference;
   std::map<FDExtractorKey,FDExtractorBase*> m_entries;
   Int m_index;
};
 
class FDExtractorList : public FDExtractorBase
{
   friend FDExtractor;
   friend FDAvp;
   friend FDMessage;
 
public:
   FDExtractorList( FDExtractor &parent, FDDictionaryEntryAVP &de );
   virtual ~FDExtractorList();
 
   eFDExtractorType getExtractorType() { return etExtractorList; }
 
   FDExtractor &getParent() { return *m_parent; }
 
   virtual FDExtractor *createExtractor() = 0;
 
   Void addExtractor( FDExtractor *e );
 
   Bool exists();
 
   Void dump();
 
protected:
   std::list<FDExtractor*> &getList();
 
private:
   FDExtractorList();
 
   FDExtractor *m_parent;
   std::list<FDExtractor*> m_list;
};
 
class FDExtractorAvp : public FDExtractorBase
{
public:
   FDExtractorAvp( FDExtractor &extractor, FDDictionaryEntryAVP &de, Bool dedel = false );
   virtual ~FDExtractorAvp();
 
   eFDExtractorType getExtractorType() { return etAvp; }
 
   Void setAvp( struct avp *a ) { m_avp.setAvp( a ); }
   struct avp *getAvp() { return m_avp.getAvp(); }
   union avp_value *getAvpValue() { return m_avp.getAvpValue(); }
 
   Bool exists();
 
   Bool get( int32_t &v )                    { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( uint32_t &v )                   { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( uint64_t &v )                   { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( float &v )                      { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( double &v )                     { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( int64_t &v )                    { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( std::string &v )                { if ( !exists() ) return false; return m_avp.get( v ); }
   Bool get( char *data, size_t &len )       { if ( !exists() ) return false; return m_avp.get( data, len ); }
   Bool get( uint8_t *data, size_t &len )    { if ( !exists() ) return false; return m_avp.get( data, len ); }
   Bool get( sSS &ss )                       { if ( !exists() ) return false; return m_avp.get( ss ); }
   Bool get( ETime &t )                      { if ( !exists() ) return false; return m_avp.get( t ); }
 
   Void dump();
 
   Bool getJson( std::string &json );
 
private:
   FDExtractor &m_extractor;
   FDAvp m_avp;
};
 
class FDExtractorAvpList : public FDExtractorBase
{
public:
   FDExtractorAvpList( FDExtractor &extractor, FDDictionaryEntryAVP &de );
   virtual ~FDExtractorAvpList();
 
   eFDExtractorType getExtractorType() { return etAvpList; }
 
   std::list<FDExtractorAvp*> &getList();
 
   Bool exists();
 
   Void dump();
 
private:
   FDExtractorAvpList();
 
   FDExtractor *m_parent;
   std::list<FDExtractorAvp*> m_list;
};
 
 
class FDHook
{
public:
   FDHook();
 
   virtual Void process(enum fd_hook_type type, struct msg * msg, struct peer_hdr * peer,
      Void * other, struct fd_hook_permsgdata *pmd) = 0;
 
   Bool registerHook(UInt hookmask);
   Void unregisterHook();
 
   struct fd_hook_hdl *getHandle() { return m_hdl; }
 
   UInt getHookMask() { return m_hookmask; }
 
private:
   static Void hook_cb(enum fd_hook_type type, struct msg * msg, struct peer_hdr * peer,
      Void * other, struct fd_hook_permsgdata *pmd, Void * regdata);
   
   UInt m_hookmask;
   struct fd_hook_hdl *m_hdl;
};
 
 
class FDUtility
{
public:
   static Void splitDiameterFQDN( std::string &fqdn, std::string &host, std::string &realm );
   static Void splitDiameterFQDN( const char *fqdn, std::string &host, std::string &realm ) { std::string sfqdn( fqdn ); splitDiameterFQDN( sfqdn, host, realm ); }
 
   static size_t str2tbcd( const char *src, size_t srclen, uint8_t *dst, size_t dstlen );
   static size_t str2tbcd( const char *src, uint8_t *dst, size_t dstlen );
   static size_t str2tbcd( const std::string &src, uint8_t *dst, size_t dstlen );
 
   static size_t tbcd2str( uint8_t *src, size_t srclen, char *dst, size_t dstlen );
   static size_t tbcd2str( uint8_t *src, size_t srclen, std::string &dst );
};
 
#endif // #define __EFD_H