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

#ifndef __DIAMETER_API_H__
#define __DIAMETER_API_H__

#include <diameter_parser_api.h>

#if defined (WIN32)
#  if defined (DIAMETERBASEPROTOCOL_EXPORTS)
#    define DIAMETERBASEPROTOCOL_EXPORT ACE_Proper_Export_Flag
#    define DIAMETERBASEPROTOCOL_EXPORT_ONLY ACE_Proper_Export_Flag
#    define DIAMETERBASEPROTOCOL_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
#    define DIAMETERBASEPROTOCOL_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
#  else
#    define DIAMETERBASEPROTOCOL_EXPORT ACE_Proper_Import_Flag
#    define DIAMETERBASEPROTOCOL_EXPORT_ONLY
#    define DIAMETERBASEPROTOCOL_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
#    define DIAMETERBASEPROTOCOL_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
#  endif   /* ! DIAMETERBASEPROTOCOL_EXPORTS */
#else
#  define DIAMETERBASEPROTOCOL_EXPORT
#  define DIAMETERBASEPROTOCOL_EXPORT_ONLY
#  define DIAMETERBASEPROTOCOL_SINGLETON_DECLARATION(T)
#  define DIAMETERBASEPROTOCOL_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
#endif     /* WIN32 */

// forward declarations
class AAAServerSessionFactory;

class AAAApplicationHandle : public AAA_JobData { };

typedef void* AAASessionPayload;

class DIAMETERBASEPROTOCOL_EXPORT AAAApplicationCore {
    public:
        AAAApplicationCore() { }

        AAAApplicationCore(char *configFileName, 
            AAA_Task *task = 0) {
            Open(configFileName, task);
        }

        ~AAAApplicationCore() {
            Close();
        }

        AAAReturnCode Open(char *configFileName = NULL, 
            AAA_Task *task = 0);

        AAAReturnCode Close();

        AAAReturnCode RegisterServerSessionFactory
            (AAAServerSessionFactory *factory);

        AAAReturnCode RemoveServerSessionFactory
            (AAAServerSessionFactory *factory);

        AAAApplicationHandle &GetAppHandle() {
            return *handle;
        }

        diameter_unsigned32_t GetNumActivePeerConnections();

        AAA_Task& GetTask();


    private:
        boost::shared_ptr<AAAApplicationHandle> handle;
};

class DIAMETERBASEPROTOCOL_EXPORT AAAEventHandler {
    public:
        AAAEventHandler(AAAApplicationCore &c) : core(c) { 
        }

        virtual ~AAAEventHandler() { }

        virtual AAAReturnCode HandleMessage(AAAMessage &msg) {
            return (AAA_ERR_SUCCESS);
        }

        virtual AAAReturnCode HandleDisconnect() {
            return (AAA_ERR_SUCCESS);
        }

        virtual AAAReturnCode HandleTimeout() {
            return (AAA_ERR_SUCCESS);
        }

        virtual AAAReturnCode HandleSessionTimeout() {
            return (AAA_ERR_SUCCESS);
        }

        virtual AAAReturnCode HandleAuthLifetimeTimeout() {
            return (AAA_ERR_SUCCESS);
        }

        virtual AAAReturnCode HandleAuthGracePeriodTimeout() {
            return (AAA_ERR_SUCCESS);
        }

        virtual AAAReturnCode HandleAbort() {
            return (AAA_ERR_SUCCESS);
        }

        const AAAApplicationCore &GetApplicationCore() {
            return core;
        }

    protected:
        AAAApplicationCore &core; 
};

// forward declaration
class AAASessionMessageHandler;

class DIAMETERBASEPROTOCOL_EXPORT AAASession : public AAAEventHandler {
   public:
       typedef enum {
           EVENT_AUTH_REQUEST = 0, 
           EVENT_AUTH_SUCCESS,     
           EVENT_AUTH_CONTINUE,    
           EVENT_AUTH_FAILED,      
           EVENT_ACCT_SUCCESS,     
           EVENT_NO_SERVICE,       
           EVENT_PROC_ERROR        
       } EVENT;

    public:
        AAASession(AAAApplicationCore &appCore, 
                   diameter_unsigned32_t appId);

        virtual ~AAASession();

        virtual AAAReturnCode SetTimeout(time_t timeout);

        virtual AAAReturnCode RegisterMessageHandler(AAASessionMessageHandler *handler);

        virtual AAAReturnCode RemoveMessageHandler(AAASessionMessageHandler *handler);

        virtual AAAReturnCode Update(AAASession::EVENT event) = 0;

        const AAASessionHandle GetSessionHandle();

        diameter_unsigned32_t GetApplicationId() { return id; }

        void GetSessionId(diameter_octetstring_t &id);

    protected:
        AAASessionHandle handle;

        diameter_unsigned32_t id; 
};

class DIAMETERBASEPROTOCOL_EXPORT AAASessionMessageHandler : public AAAEventHandler {
   public:
      AAASessionMessageHandler(AAAApplicationCore &appCore,
                               AAACommandCode cmdCode);

      AAACommandCode GetCommandCode() { return code; }

   private:
      AAACommandCode code; 
};

class DIAMETERBASEPROTOCOL_EXPORT AAAClientSession : public AAASession {
    public:
        AAAClientSession(AAAApplicationCore &appCore,
                         diameter_unsigned32_t id);

        virtual ~AAAClientSession();
        
        AAAReturnCode Start();

        AAAReturnCode SetOptionalSIDValue(std::string optVal);

        AAAReturnCode Update(AAASession::EVENT event);

        AAAReturnCode End();
};

class DIAMETERBASEPROTOCOL_EXPORT AAAServerSession : public AAASession {
    public:
        AAAServerSession(AAAApplicationCore &appCore,
                         diameter_unsigned32_t id);

        virtual ~AAAServerSession();

        AAAReturnCode Update(AAASession::EVENT event);

        AAAReturnCode Abort();
};

class DIAMETERBASEPROTOCOL_EXPORT AAAServerSessionFactory {
    public:
       AAAServerSessionFactory(diameter_unsigned32_t appId,
                               AAASessionType type = AAA_STYPE_AUTHENTICATION);

       virtual ~AAAServerSessionFactory();

       diameter_unsigned32_t GetApplicationId() { return id; }

       AAASessionType GetType() { return type; }

       virtual AAASession *CreateInstance(AAAApplicationCore &core, 
           diameter_unsigned32_t id) = 0;

    private:
       diameter_unsigned32_t id; 
       AAASessionType type; 
};

template<class SESSION_SERVER>
class AAAServerSessionClassFactory : public AAAServerSessionFactory
{
    public:
       AAAServerSessionClassFactory(diameter_unsigned32_t id, 
                                    AAASessionType type = AAA_STYPE_AUTHENTICATION) : 
                                    AAAServerSessionFactory(id, type) { };

       AAASession *CreateInstance(AAAApplicationCore &core, diameter_unsigned32_t id) {
          return new SESSION_SERVER(core, id);
       }
};

class DIAMETERBASEPROTOCOL_EXPORT AAAMessageControl {
    public:
        AAAMessageControl(AAASession *session);

        ~AAAMessageControl();

        AAAReturnCode SetResultCode(AAAMessage &response, 
                                    AAAMessage &request, 
                                    AAAResultCode resultCode);

        AAAReturnCode Send(AAAMessage &msg);

    protected:
        AAASession &session; 
};

class DIAMETERBASEPROTOCOL_EXPORT AAAAccountingSession : public AAASession
{
    public:
        AAAAccountingSession(AAAApplicationCore &appCore,
                             diameter_unsigned32_t id);

        virtual ~AAAAccountingSession();

        AAAReturnCode Send(AAAMessage &reqMsg);

        AAAReturnCode Update(AAASession::EVENT event);
};

class DIAMETERBASEPROTOCOL_EXPORT AAAAccountingClientSession : public AAAAccountingSession
{
    public:
        typedef enum {
            RECTYPE_EVENT = 1,
            RECTYPE_START = 2,
            RECTYPE_INTERIM = 3,
            RECTYPE_STOP = 4
        } RECTYPE;

    public:
        AAAAccountingClientSession(AAAApplicationCore &appCore,
                                   diameter_unsigned32_t id);

        virtual ~AAAAccountingClientSession();

        AAAReturnCode SetInterimRecordInterval(RECTYPE type, 
                                               int interval = 0,
                                               AAASessionPayload payload = NULL);

        virtual AAAReturnCode HandleInterimRecordEvent(RECTYPE type, 
                                                       AAASessionPayload payload);
};

class DIAMETERBASEPROTOCOL_EXPORT AAAAccountingRecTransformer
{
    public:
        AAAAccountingRecTransformer();

        virtual ~AAAAccountingRecTransformer();

        virtual AAAReturnCode Convert(AAAMessage *msg) = 0;

        virtual AAAReturnCode OutputRecord(AAAMessage *originalMsg) = 0;
};

class DIAMETERBASEPROTOCOL_EXPORT AAAAccountingXMLRecTransformer : public AAAAccountingRecTransformer
{
    public:
        AAAAccountingXMLRecTransformer();

        ~AAAAccountingXMLRecTransformer();

        virtual AAAReturnCode Convert(AAAMessage *msg);

        virtual AAAReturnCode OutputRecord(AAAMessage *originalMsg);

   protected:
        AAASessionPayload record; 
        ACE_UINT32 record_size; 
};

#if defined(AAA_ODBC_XFORMER)

class DIAMETERBASEPROTOCOL_EXPORT AAAAccountingODBCRecTransformer : public AAAAccountingXMLRecTransformer
{
    public:
        AAAAccountingODBCRecTransformer();

        ~AAAAccountingODBCRecTransformer();

        virtual AAAReturnCode OutputRecord(AAAMessage *originalMsg);
};

#endif /* AAA_ODBC_XFORMER */

class DIAMETERBASEPROTOCOL_EXPORT AAAAccountingServerSession : public AAAAccountingSession
{
    public:
        AAAAccountingServerSession(AAAApplicationCore &appCore,
                                   diameter_unsigned32_t id);

        virtual ~AAAAccountingServerSession();

        void SetTransformer(AAAAccountingRecTransformer *trns) { transformer = trns; }

        AAAAccountingRecTransformer *GetTransformer() { return transformer; }

    protected:
        AAAAccountingRecTransformer *transformer; 
};


class DIAMETERBASEPROTOCOL_EXPORT AAAProxyServices
{
    public:
        AAAProxyServices(AAAApplicationCore &appCore) :
            core(appCore) {
        }

        virtual ~AAAProxyServices() { }

        AAAReturnCode RegisterMessageHandler(diameter_unsigned32_t appId,
                                             AAAEventHandler *handler);

        AAAReturnCode RemoveMessageHandler(diameter_unsigned32_t appId);

    protected:
        AAAApplicationCore &core;
};

#endif   // __DIAMETER_API_H__ 

---