aaa_data_defs.h

Diameter协议栈

   AAA_RunTime runtime;                // runtime configuration
   AAA_DataGeneral general;            // general configuration
   AAA_DataParser parser;              // parser configuration
   AAA_DataTransportMngt transport;    // transport configuration
   AAA_DataSessionMngt session;        // session configuration
   AAA_DataLog log;                    // logging configuration
} AAA_DataRoot;

typedef struct {
   diameter_unsigned32_t reAuthType;   // re-authentication type
   diameter_unsigned32_t resultCode;   // result code
} AAA_ReAuthValue;

typedef ACE_Singleton<AAA_DataRoot, ACE_Thread_Mutex> AAA_DataRoot_S;
#define AAA_CFG_ROOT()            (AAA_DataRoot_S::instance())
#define AAA_CFG_RUNTIME()         (&(AAA_DataRoot_S::instance()->runtime))
#define AAA_CFG_GENERAL()         (&(AAA_DataRoot_S::instance()->general))
#define AAA_CFG_PARSER()          (&(AAA_DataRoot_S::instance()->parser))
#define AAA_CFG_TRANSPORT()       (&(AAA_DataRoot_S::instance()->transport))
#define AAA_CFG_SESSION()         (&(AAA_DataRoot_S::instance()->session))
#define AAA_CFG_AUTH_SESSION()    (&(AAA_DataRoot_S::instance()->session.authSessions))
#define AAA_CFG_ACCT_SESSION()    (&(AAA_DataRoot_S::instance()->session.acctSessions))
#define AAA_CFG_LOG()             (&(AAA_DataRoot_S::instance()->log))

class AAA_BaseException
{
   public:
      typedef enum {
          ALLOC_FAILURE = 0,
          INVALID_ID_TYPE,
          MISSING_SESSION_ID,
      } ERROR_CODE;
    
   public:
      AAA_BaseException(int code, std::string &desc) :
        m_Code(code), m_Description(desc) {
      }
      AAA_BaseException(int code, const char* desc) :
        m_Code(code), m_Description(desc) {
      }
      int &Code() {
          return m_Code;
      }
      std::string &Description() {
          return m_Description;
      }

   private:
      int m_Code;
      std::string m_Description;
};

class AAA_MsgQuery
{
    public:
       AAA_MsgQuery(AAAMessage &msg) :
           m_Msg(msg) {
       }
       bool IsRequest() {
           return m_Msg.hdr.flags.r;
       }
       bool IsAnswer() {
           return ! IsRequest();
       }
       bool IsCapabilities() {
           return (m_Msg.hdr.code == AAA_MSGCODE_CAPABILITIES_EXCHG);
       }
       bool IsReAuth() {
           return (m_Msg.hdr.code == AAA_MSGCODE_REAUTH);
       }
       bool IsWatchDog() {
           return (m_Msg.hdr.code == AAA_MSGCODE_WATCHDOG);
       }
       bool IsPeerDisconnect() {
           return (m_Msg.hdr.code == AAA_MSGCODE_DISCONNECT_PEER);
       }
       diameter_unsigned32_t Code() {
           return m_Msg.hdr.code;
       }
       bool IsBaseProtocol() {
           static diameter_unsigned32_t msgBaseProto[] = {
               AAA_MSGCODE_ABORTSESSION,
               AAA_MSGCODE_SESSIONTERMINATION,
               AAA_MSGCODE_CAPABILITIES_EXCHG,
               AAA_MSGCODE_WATCHDOG,
               AAA_MSGCODE_DISCONNECT_PEER,
               AAA_MSGCODE_ACCOUNTING,
               AAA_MSGCODE_REAUTH
           };
           for (int i=0;
                i<sizeof(msgBaseProto)/sizeof(diameter_unsigned32_t);
                i++) {
               if (msgBaseProto[i] == m_Msg.hdr.code) {
                   return true;
               }
           }
           return false;
       }

    private:
       AAAMessage &m_Msg;
};

template <class ARG>
class AAA_ProtectedQueue : 
   private std::list<ARG>
{
   public:
      virtual ~AAA_ProtectedQueue() {
      }
      virtual void Enqueue(ARG arg) {
         ACE_Write_Guard<ACE_RW_Mutex> guard(m_Lock);
         std::list<ARG>::push_back(arg);  
      }
      virtual ARG Dequeue() {
         ACE_Write_Guard<ACE_RW_Mutex> guard(m_Lock);
         ARG a = std::list<ARG>::front();
         std::list<ARG>::pop_front();
         return a;
      }
      virtual bool IsEmpty() {
         ACE_Read_Guard<ACE_RW_Mutex> guard(m_Lock);
         return std::list<ARG>::empty() ? true : false;
      }

   private:
      ACE_RW_Mutex m_Lock;
};

template <class ARG> 
class AAA_IterAction 
{
   public:
      // return TRUE to delete entry in iteration
      // return FALSE to sustain entry
      virtual bool operator()(ARG&)=0;
      
   protected:
      virtual ~AAA_IterAction() {
      }
      AAA_IterAction() {
      }
};

template <class INDEX, 
          class DATA>
class AAA_ProtectedMap : 
   private std::map<INDEX, DATA>
{
   public:
      virtual ~AAA_ProtectedMap() {
      }
      virtual void Add(INDEX ndx, DATA data) {
         ACE_Write_Guard<ACE_RW_Mutex> guard(m_Lock);
         std::map<INDEX, DATA>::insert(std::pair
             <INDEX, DATA>(ndx, data));
      }
      virtual bool Lookup(INDEX ndx, DATA &data) {
         ACE_Read_Guard<ACE_RW_Mutex> guard(m_Lock);
         typename std::map<INDEX, DATA>::iterator i;
         i = std::map<INDEX, DATA>::find(ndx);
         if (i != std::map<INDEX, DATA>::end()) {
             data = i->second;
             return (true);
         }
         return (false);
       }
      virtual bool Remove(INDEX ndx,
                          AAA_IterAction<DATA> &e) {
         ACE_Write_Guard<ACE_RW_Mutex> guard(m_Lock);
         typename std::map<INDEX, DATA>::iterator i;
         i = std::map<INDEX, DATA>::find(ndx);
         if (i != std::map<INDEX, DATA>::end()) {
             e(i->second);
             std::map<INDEX, DATA>::erase(i);
             return (true);
         }
         return (false);
      }
      virtual bool IsEmpty() {
         ACE_Read_Guard<ACE_RW_Mutex> guard(m_Lock);
         return std::map<INDEX, DATA>::empty() ? true : false;
      }
      virtual void Iterate(AAA_IterAction<DATA> &e) {
         ACE_Write_Guard<ACE_RW_Mutex> guard(m_Lock);
         typename std::map<INDEX, DATA>::iterator i =
             std::map<INDEX, DATA>::begin();
         while (i != std::map<INDEX, DATA>::end()) {
             if (e(i->second)) {
                 typename std::map<INDEX, DATA>::iterator h = i;
                 i ++;
                 std::map<INDEX, DATA>::erase(h);
                 continue;
             }
             i ++;
         }
      }

   private:
      ACE_RW_Mutex m_Lock;
};

template <class ARG>
class AAA_ProtectedPtrQueue 
{
   public:
      void Enqueue(std::auto_ptr<ARG> a) {
         m_Queue.Enqueue(a.release());
      }
      std::auto_ptr<ARG> Dequeue() {
         std::auto_ptr<ARG> arg(m_Queue.Dequeue());
         return arg;
      }

   private:
      AAA_ProtectedQueue<ARG*> m_Queue;
};

template <class ARG>
class AAA_ProtectedPtrMap
{
   public:
      void Enqueue(std::auto_ptr<ARG> a) {
         m_Queue.Enqueue(a.release());
      }
      std::auto_ptr<ARG> Dequeue() {
         std::auto_ptr<ARG> arg(m_Queue.Dequeue());
         return arg;
      }

   private:
      AAA_ProtectedQueue<ARG*> m_Queue;
};

class AAA_RangedValue
{
   public:
      typedef enum {
          DEFAULT_LOW  = 0,
          DEFAULT_HIGH = 3,
      };

   public:
      AAA_RangedValue(int level = DEFAULT_LOW,
                      int low = DEFAULT_LOW, 
                      int high = DEFAULT_HIGH) {
          Reset(level, low, high);
      }      
      virtual ~AAA_RangedValue() {
      }
      virtual int operator++() {
          m_CurrentLevel += 1;
          return (m_CurrentLevel > m_HighThreshold) ? true : false;
      }
      virtual int operator--() {
          m_CurrentLevel -= 1;
          return (m_CurrentLevel < m_LowThreshold) ? true : false;
      }
      virtual int operator()() {
          return m_CurrentLevel;
      }
      virtual bool InRange() {
          return ((m_CurrentLevel > m_LowThreshold) &&
                  (m_CurrentLevel < m_HighThreshold));
      }
      void Reset(int level = DEFAULT_LOW,
                 int low = DEFAULT_LOW, 
                 int high = DEFAULT_HIGH) {
          m_CurrentLevel = level;
          m_LowThreshold = low;
          m_HighThreshold = high;
      } 

   private:
      int m_CurrentLevel;
      int m_LowThreshold;
      int m_HighThreshold;
};

#endif // __AAA_DEFS_H__