agentx_session.h

Go to the documentation of this file.

/*_############################################################################
  _## 
  _##  agentx_session.h  
  _## 
  _##
  _##  AgentX++ 2
  _##  -------------------------------------
  _##  Copyright (C) 2000-2013 - Frank Fock
  _##  
  _##  Use of this software is subject to the license agreement you received
  _##  with this software and which can be downloaded from 
  _##  http://www.agentpp.com
  _##
  _##  This is licensed software and may not be used in a commercial
  _##  environment, except for evaluation purposes, unless a valid
  _##  license has been purchased.
  _##  
  _##########################################################################*/

#ifndef _agentx_session_h_
#define _agentx_session_h_

#include <agent_pp/agent++.h>
#include <agent_pp/snmp_pp_ext.h>
#include <agentx_pp/agentx_reg.h>
#include <agentx_pp/agentx_def.h>
#include <agentx_pp/agentx_threads.h>
#include <agentx_pp/agentx_peer.h>

#ifdef AGENTPP_NAMESPACE
namespace Agentpp {
#endif

#if !defined (AGENTXPP_DECL_TEMPL_LIST_VBX)
#define AGENTXPP_DECL_TEMPL_LIST_VBX
        AGENTXPP_DECL_TEMPL template class AGENTXPP_DECL        List<Vbx>;
#endif

class AGENTXPP_DECL AgentXSession {

friend class AgentXRequest;
friend class AgentXQueue;
friend class AgentXSessions;

 public:
        AgentXSession();
        AgentXSession(u_int);
        
        ~AgentXSession();

        int             get_state() const       { return state; }
        void            set_state(int s)        { state = s; }

        u_int           get_id() const          { return sessionID; }
        void            set_id(u_int i) { sessionID = i; }

        bool            get_byte_order() const { return networkByteOrder; }
        void            set_byte_order(bool newOrder) 
                                        { networkByteOrder = newOrder; }
        u_char          get_timeout() const     { return defaultTimeout; }
        void            set_timeout(u_char t)   { defaultTimeout = t; }
        Oidx            get_oid() const         { return id; }
        NS_SNMP OctetStr        get_descr() const       { return descr; } 

        void            set_peer(const AgentXPeer& p) { peer = p; }
        AgentXPeer      get_peer() const { return peer; }

        static u_int    get_next_session_id();

        void            add_agent_caps(const NS_SNMP OctetStr& c, const Oidx& oid) 
                                        { sysORIDs.add(new Vbx(oid, c));}
        void            remove_agent_caps(const NS_SNMP OctetStr&, const Oidx& id);

        ListCursor<Vbx>* get_agent_caps() { 
                                return new ListCursor<Vbx>(&sysORIDs); }

        AgentXSession&  operator=(const AgentXSession&);

        void            inc_timeouts() { consecutiveTimeouts++; }
        void            reset_timeouts() { consecutiveTimeouts = 0; }
        bool         is_unable_to_respond() 
                            { return (consecutiveTimeouts >= 
                                      AGENTX_MAX_TIMEOUTS); }  

        AgentXPeer      peer;

 protected:
        u_int           sessionID;

        bool            networkByteOrder;
        u_char          defaultTimeout;

        int             state;

        Oidx            id;
        NS_SNMP OctetStr descr;

        List<Vbx>       sysORIDs;

        u_char          consecutiveTimeouts;
};


#if !defined (AGENTXPP_DECL_TEMPL_LIST_AGENTXSESSION)
#define AGENTXPP_DECL_TEMPL_LIST_AGENTXSESSION
        AGENTXPP_DECL_TEMPL template class AGENTXPP_DECL List<AgentXSession>;
#endif

class AGENTXPP_DECL AgentXSessions: public Synchronized
{
 public:
        AgentXSessions();
        virtual ~AgentXSessions();

        virtual bool            get_session(u_int, AgentXSession&);
       
        virtual AgentXSession*  get_session(u_int);     

        virtual AgentXSession*  remove(u_int);

        virtual u_int           make_new_session(bool, u_char, 
                                                 const Oidx&, 
                                                 const NS_SNMP OctetStr&,
                                                 const AgentXPeer&);
        
        ListCursor<AgentXSession> get_sessions() 
          { return ListCursor<AgentXSession>(&sessions); }

        void                    clear() { sessions.clearAll(); }

        virtual void            remove(const AgentXPeer&);

        List<AgentXSession>*    remove_sessions_of_peer(const AgentXPeer&);

        List<AgentXSession>*    get_sessions_of_peer(const AgentXPeer&);

 protected:

        u_int           lastSessionID;

        List<AgentXSession> sessions;
};

#ifdef AGENTPP_NAMESPACE
}
#endif


#endif