snmp_pp_ext.h

Go to the documentation of this file.

/*_############################################################################
  _## 
  _##  snmp_pp_ext.h  
  _## 
  _##
  _##  AGENT++ API Version 3.5.28
  _##  -----------------------------------------------
  _##  Copyright (C) 2000-2007 Frank Fock, Jochen Katz
  _##  
  _##  LICENSE AGREEMENT
  _##
  _##  WHEREAS,  Frank  Fock  and  Jochen  Katz  are  the  owners of valuable
  _##  intellectual  property rights relating to  the AGENT++ API and wish to
  _##  license AGENT++ subject to the  terms and conditions set forth  below;
  _##  and
  _##
  _##  WHEREAS, you ("Licensee") acknowledge  that Frank Fock and Jochen Katz
  _##  have the right  to grant licenses  to the intellectual property rights
  _##  relating to  AGENT++, and that you desire  to obtain a license  to use
  _##  AGENT++ subject to the terms and conditions set forth below;
  _##
  _##  Frank  Fock    and Jochen   Katz   grants  Licensee  a  non-exclusive,
  _##  non-transferable, royalty-free  license  to use   AGENT++ and  related
  _##  materials without  charge provided the Licensee  adheres to all of the
  _##  terms and conditions of this Agreement.
  _##
  _##  By downloading, using, or  copying  AGENT++  or any  portion  thereof,
  _##  Licensee  agrees to abide  by  the intellectual property  laws and all
  _##  other   applicable laws  of  Germany,  and  to all of   the  terms and
  _##  conditions  of this Agreement, and agrees  to take all necessary steps
  _##  to  ensure that the  terms and  conditions of  this Agreement are  not
  _##  violated  by any person  or entity under the  Licensee's control or in
  _##  the Licensee's service.
  _##
  _##  Licensee shall maintain  the  copyright and trademark  notices  on the
  _##  materials  within or otherwise  related   to AGENT++, and  not  alter,
  _##  erase, deface or overprint any such notice.
  _##
  _##  Except  as specifically   provided in  this  Agreement,   Licensee  is
  _##  expressly   prohibited  from  copying,   merging,  selling,   leasing,
  _##  assigning,  or  transferring  in  any manner,  AGENT++ or  any portion
  _##  thereof.
  _##
  _##  Licensee may copy materials   within or otherwise related   to AGENT++
  _##  that bear the author's copyright only  as required for backup purposes
  _##  or for use solely by the Licensee.
  _##
  _##  Licensee may  not distribute  in any  form  of electronic  or  printed
  _##  communication the  materials  within or  otherwise  related to AGENT++
  _##  that  bear the author's  copyright, including  but  not limited to the
  _##  source   code, documentation,  help  files, examples,  and benchmarks,
  _##  without prior written consent from the authors.  Send any requests for
  _##  limited distribution rights to fock@agentpp.com.
  _##
  _##  Licensee  hereby  grants  a  royalty-free  license  to  any  and   all 
  _##  derivatives  based  upon this software  code base,  that  may  be used
  _##  as a SNMP  agent development  environment or a  SNMP agent development 
  _##  tool.
  _##
  _##  Licensee may  modify  the sources  of AGENT++ for  the Licensee's  own
  _##  purposes.  Thus, Licensee  may  not  distribute  modified  sources  of
  _##  AGENT++ without prior written consent from the authors. 
  _##
  _##  The Licensee may distribute  binaries derived from or contained within
  _##  AGENT++ provided that:
  _##
  _##  1) The Binaries are  not integrated,  bundled,  combined, or otherwise
  _##     associated with a SNMP agent development environment or  SNMP agent
  _##     development tool; and
  _##
  _##  2) The Binaries are not a documented part of any distribution material. 
  _##
  _##
  _##  THIS  SOFTWARE  IS  PROVIDED ``AS  IS''  AND  ANY  EXPRESS OR  IMPLIED
  _##  WARRANTIES, INCLUDING, BUT NOT LIMITED  TO, THE IMPLIED WARRANTIES  OF
  _##  MERCHANTABILITY AND FITNESS FOR  A PARTICULAR PURPOSE  ARE DISCLAIMED.
  _##  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  _##  INDIRECT,   INCIDENTAL,  SPECIAL, EXEMPLARY,  OR CONSEQUENTIAL DAMAGES
  _##  (INCLUDING,  BUT NOT LIMITED  TO,  PROCUREMENT OF SUBSTITUTE  GOODS OR
  _##  SERVICES; LOSS OF  USE,  DATA, OR PROFITS; OR  BUSINESS  INTERRUPTION)
  _##  HOWEVER CAUSED  AND ON ANY THEORY  OF  LIABILITY, WHETHER IN CONTRACT,
  _##  STRICT LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  _##  IN  ANY WAY OUT OF  THE USE OF THIS  SOFTWARE,  EVEN IF ADVISED OF THE
  _##  POSSIBILITY OF SUCH DAMAGE. 
  _##
  _##
  _##  Stuttgart, Germany, Wed May  2 22:12:11 CEST 2007 
  _##  
  _##########################################################################*/

#ifndef _SNMP_PP_EXT_H_
#define _SNMP_PP_EXT_H_

#include <agent_pp/agent++.h>
#include <snmp_pp/oid.h>
#include <snmp_pp/pdu.h>
#include <snmp_pp/vb.h>
#include <snmp_pp/octet.h>
#include <snmp_pp/oid.h>
#include <snmp_pp/snmpmsg.h>


#define LENGTH_OF_IPADDRESS     4

#ifndef WIN32
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#endif

#ifdef SNMP_PP_NAMESPACE
#define NS_SNMP Snmp_pp::
#else
#define NS_SNMP
#endif

#ifdef AGENTPP_NAMESPACE
namespace Agentpp {
#endif


/*--------------------------- class Oidx -----------------------------*/

class AGENTPP_DECL Oidx: public NS_SNMP Oid {
public:
        Oidx() : Oid() { };

        Oidx(const char* s) : Oid(s) { };

        Oidx(const unsigned long *data, int length) : Oid(data, length) { };

        Oidx(const Oid& oid) : Oid(oid) { };

        virtual ~Oidx() { };

        Oidx            cut_left(const unsigned int) const;

        Oidx            cut_right(const unsigned int) const;


        Oidx&           mask(const NS_SNMP OctetStr&);


        static Oidx     cut_left(const Oidx&, const unsigned int);

        static Oidx     cut_right(const Oidx&, const unsigned int);

        unsigned long   last() const;

        virtual Oidx&   operator=(unsigned long l);

        Oidx            &operator+=(NS_SNMP IpAddress&); 
        Oidx            &operator+=(const char *); 
        Oidx            &operator+=(const unsigned long i);
        Oidx            &operator+=(const Oid &);

        int             in_subtree_of(const Oidx& o) const;

        int             is_root_of(const Oidx& o) const;

        int             compare(const Oidx&, const NS_SNMP OctetStr&) const; 

        int             compare(const Oidx&, u_int) const; 

        NS_SNMP OctetStr        as_string() const;

        static Oidx     from_string(const NS_SNMP OctetStr&, boolean withLength=TRUE);

        Oidx            successor() const;

        Oidx            predecessor() const;

        Oidx            next_peer() const;
};


/*--------------------------- class Vbx -----------------------------*/

class AGENTPP_DECL Vbx: public NS_SNMP Vb {
public:
        Vbx(): Vb() { }
        Vbx(const NS_SNMP Vb& vb): Vb(vb) { }
        Vbx(const NS_SNMP Oid& oid): Vb(oid) { }

        Vbx(const NS_SNMP Oid& oid, const NS_SNMP SnmpSyntax &val): Vb(oid) {
          set_value(val); 
        }

        Oidx            get_oid() const { return iv_vb_oid; };

        void            get_oid(Oidx& oid) const { oid = iv_vb_oid; };

        void            clear();

        Vbx*            clone() const { return new Vbx(*this); }

        friend int      operator==(const Vbx&, const Vbx&);

        static boolean  equal(Vbx*, Vbx*, int); 

        static int      to_asn1(Vbx*, int, unsigned char*&, int&);

        static int      from_asn1(Vbx*&, int&, unsigned char*&, int&);

 private:
        static unsigned char* asn_build_long_len_sequence(unsigned char *,
                                                          int*,
                                                          unsigned char,
                                                          int, int);
        static unsigned char* asn_build_long_length(unsigned char*,
                                                    int*,
                                                    int,
                                                    int);
};
 

/*------------------------- class OidxRange ---------------------------*/

class AGENTPP_DECL OidxRange {

public:
        OidxRange();

        OidxRange(const Oidx&, const Oidx&);

        OidxRange(const OidxRange&);

        virtual ~OidxRange();

        virtual OidxRange* clone() const;

        virtual int     operator==(const OidxRange&) const;
        virtual int     operator<(const OidxRange&) const;
        virtual int     operator>(const OidxRange&) const;

        virtual int     includes(const Oidx&) const;

        virtual int     includes_excl(const Oidx&) const;

        virtual boolean covers(const OidxRange&) const;

        virtual boolean overlaps(const OidxRange&) const;

        virtual Oidx    get_lower() const;

        virtual Oidx    get_upper() const;

        Oidx lower, upper;
};


/*--------------------------- class Pdux -----------------------------*/

class AGENTPP_DECL Pdux: public NS_SNMP Pdu {
public:
        Pdux(): Pdu() { }
        Pdux(NS_SNMP Vb* pvbs, const int pvb_count): Pdu(pvbs, pvb_count) { }
        Pdux(const Pdu& pdu): Pdu(pdu) { }
        Pdux(const Pdux& pdu): Pdu(pdu) { }

        virtual ~Pdux() { }

        void    clear();

        // const redefinitions of originals: 
        Pdux&   operator+=(const NS_SNMP Vb&);

        virtual Pdux*   clone() const { return new Pdux(*this); }
};


/*--------------------------- class Snmpx -----------------------------*/

class AGENTPP_DECL Snmpx: public NS_SNMP Snmp {
public:
        Snmpx (int &status , u_short port): Snmp(status, port) {};

#ifdef SNMP_PP_WITH_UDPADDR

        Snmpx(int& status, const NS_SNMP UdpAddress& addr): Snmp(status, addr) { }
#endif

#ifdef _SNMPv3          

        int receive(struct timeval*, Pdux&, NS_SNMP UTarget&);
#else

        int receive(struct timeval*, Pdux&, NS_SNMP UdpAddress&, 
                    NS_SNMP snmp_version&, NS_SNMP OctetStr&);
#endif
#ifdef _SNMPv3

        int send (Pdux, NS_SNMP SnmpTarget*);
#else

        int send (Pdux, NS_SNMP UdpAddress, NS_SNMP snmp_version, NS_SNMP OctetStr);
#endif

        u_short get_port();

        SnmpSocket      get_session_fds() { return iv_snmp_session; }


protected:
        unsigned long ProcessizedReqId(unsigned short);
        unsigned long MyMakeReqId();
        
        int snmp_engine( NS_SNMP Pdu &,          // pdu to use
                         long int,       // # of non repititions
                         long int,       // # of max repititions
                         NS_SNMP SnmpTarget&,    // from this target
                         const NS_SNMP snmp_callback cb, 
                         const void * cbd);
};    

#ifdef AGENTPP_NAMESPACE
}
#endif

#endif

---