example.c

非常不错的网管开发包

/*
 *  Template MIB group implementation - example.c
 *
 */

/* include important headers */
#include <config.h>
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif

/* needed by util_funcs.h */
#if TIME_WITH_SYS_TIME
# ifdef WIN32
#  include <sys/timeb.h>
# else
#  include <sys/time.h>
# endif
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

#if HAVE_WINSOCK_H
#include <winsock.h>
#endif

/* mibincl.h contains all the snmp specific headers to define the
   return types and various defines and structures. */
#include "mibincl.h"

/* header_generic() comes from here */
#include "util_funcs.h"

#include "agent_read_config.h"

/* include our .h file */
#include "example.h"


   /*
    *  Certain objects can be set via configuration file directives.
    *  These variables hold the values for such objects, as they need to
    *   be accessible to both the config handlers, and the callback routine.
    */
#define EXAMPLE_STR_LEN	300
#define EXAMPLE_STR_DEFAULT	"life the universe and everything"
int	example_int = 42;
char	example_str[ EXAMPLE_STR_LEN ];

	/* Forward declarations for the config handlers */
void example_parse_config_exampleint( const char *token, char *cptr );
void example_parse_config_examplestr( const char *token, char *cptr );
void example_free_config_exampleint( void );
void example_free_config_examplestr( void );


	/*********************
	 *
	 *  Initialisation & common implementation functions
	 *
	 *********************/

    /*
     * This array structure defines a representation of the
     *  MIB being implemented.
     *
     * The type of the array is 'struct variableN', where N is
     *  large enough to contain the longest OID sub-component
     *  being loaded.  This will normally be the maximum value
     *  of the fifth field in each line.  In this case, the second
     *  and third entries are both of size 2, so we're using
     *  'struct variable2'
     *
     * The supported values for N are listed in <agent/var_struct.h>
     *  If the value you need is not listed there, simply use the
     *  next largest that is.
     *
     * The format of each line is as follows
     *  (using the first entry as an example):
     *	    1: EXAMPLESTRING:
     *		The magic number defined in the example header file.
     *		This is passed to the callback routine and is used
     *		  to determine which object is being queried.
     *	    2: ASN_OCTET_STR:
     *		The type of the object.
     *		Valid types are listed in <snmp_impl.h>
     *	    3: RONLY (or RWRITE):
     *		Whether this object can be SET or not.
     *	    4: var_example:
     *		The callback routine, used when the object is queried.
     *		This will usually be the same for all objects in a module
     *		  and is typically defined later in this file.
     *	    5: 1:
     *		The length of the OID sub-component (the next field)
     *	    6: {1}:
     *		The OID sub-components of this entry.
     *		In other words, the bits of the full OID that differ
     *		  between the various entries of this array.
     *		This value is appended to the common prefix (defined later)
     *		  to obtain the full OID of each entry.
     */
struct variable2 example_variables[] = {
    { EXAMPLESTRING,    ASN_OCTET_STR, RONLY, var_example, 1, {1}},
    { EXAMPLEINTEGER,   ASN_INTEGER,   RWRITE, var_example, 2, {2,1}},
    { EXAMPLEOBJECTID,  ASN_OBJECT_ID, RONLY, var_example, 2, {2,2}},
    { EXAMPLETIMETICKS, ASN_TIMETICKS, RONLY, var_example, 1, {3}},
    { EXAMPLEIPADDRESS, ASN_IPADDRESS, RONLY, var_example, 1, {4}},
    { EXAMPLECOUNTER,   ASN_COUNTER,   RONLY, var_example, 1, {5}},
    { EXAMPLEGAUGE,     ASN_GAUGE,     RONLY, var_example, 1, {6}},
    { EXAMPLETRIGGERTRAP, ASN_INTEGER, RWRITE, var_example, 1, {7}}
  };

    /*
     * This array defines the OID of the top of the mib tree that we're
     *  registering underneath.
     * Note that this needs to be the correct size for the OID being 
     *  registered, so that the length of the OID can be calculated.
     *  The format given here is the simplest way to achieve this.
     */
  oid example_variables_oid[] = { 1,3,6,1,4,1,2021,254 };

   

    /*
     * This function is called at the time the agent starts up
     *  to do any initializations that might be required.
     *
     * In theory it is optional and can be omitted if no
     *  initialization is needed.  In practise, every module
     *  will need to register itself (or the objects being
     *  implemented will not appear in the MIB tree), and this
     *  registration is typically done here.
     *
     * If this function is added or removed, you must re-run
     *  the configure script, to detect this change.
     */
void init_example(void)
{
    /*
     * Register ourselves with the agent to handle our mib tree.
     * The arguments are:
     *    descr:   A short description of the mib group being loaded.
     *    var:     The variable structure to load.
     *			(the name of the variable structure defined above)
     *    vartype: The type of this variable structure
     *    theoid:  The OID pointer this MIB is being registered underneath.
     */
  REGISTER_MIB("example", example_variables, variable2, example_variables_oid);


    /*
     *  Register config handlers for the two objects that can be set
     *   via configuration file directive.
     *  Also set a default value for the string object.  Note that the
     *   example integer variable was initialised above.
     */
  strcpy( example_str, EXAMPLE_STR_DEFAULT );

  snmpd_register_config_handler( "exampleint",
			example_parse_config_exampleint,
			example_free_config_exampleint,
			"exampleint value" );
  snmpd_register_config_handler( "examplestr",
			example_parse_config_examplestr,
			example_free_config_examplestr,
			"examplestr value" );
  snmpd_register_config_handler( "examplestring",
			example_parse_config_examplestr,
			example_free_config_examplestr,
			"examplestring value" );

    /*
     * One common requirement is to read values from the kernel.
     * This is usually initialised here, to speed up access when the
     *  information is read in, as a response to an incoming request.
     *
     * This module doesn't actually use this mechanism,
     * so this call is commented out here.
     */
  /* auto_nlist( "example_symbol", 0, 0 ); */
}

	/*********************
	 *
	 *  Configuration file handling functions
	 *
	 *********************/

void
example_parse_config_exampleint( const char *token, char *cptr )
{
    example_int = atoi( cptr );
}

void
example_parse_config_examplestr( const char *token, char *cptr )
{
		/*
		 * Make sure the string fits in the space allocated for it.
		 */
    if ( strlen( cptr ) < EXAMPLE_STR_LEN )
	strcpy( example_str, cptr );
    else {
		/*
		 * Truncate the string if necessary.
		 * An alternative approach would be to log an error,
		 *  and discard this value altogether.
		 */
	strncpy( example_str, cptr, EXAMPLE_STR_LEN-3 );
	example_str[ EXAMPLE_STR_LEN-3 ] = 0;
	strcat(  example_str, "..." );
    }
}

	/*  We don't need to do anything special when closing down */
void
example_free_config_exampleint( void ) {}

void
example_free_config_examplestr( void ) {}

	/*********************
	 *
	 *  System specific implementation functions
	 *
	 *********************/

    /*
     * Define the callback function used in the example_variables structure.
     * This is called whenever an incoming request refers to an object
     *  within this sub-tree.
     *
     * Four of the parameters are used to pass information in.
     * These are:
     *	  vp	  The entry from the 'example_variables' array for the
     *		   object being queried.
     *	  name	  The OID from the request.
     *	  length  The length of this OID.
     *	  exact	  A flag to indicate whether this is an 'exact' request
     *		   (GET/SET) or an 'inexact' one (GETNEXT/GETBULK).
     *
     * Four of the parameters are used to pass information back out.
     * These are:
     *	  name	   The OID being returned.
     *	  length   The length of this OID.
     *	  var_len  The length of the answer being returned.
     *    write_method   A pointer to the SET function for this object.
     *
     * Note that name & length serve a dual purpose in both roles.
     */

u_char	*
var_example(struct variable *vp,
	    oid *name,
	    size_t *length,
	    int exact,
	    size_t *var_len,
	    WriteMethod **write_method)
{
    /*
     *  The result returned from this function needs to be a pointer to
     *    static data (so that it can be accessed from outside).
     *  Define suitable variables for any type of data we may return.
     */
  static char string[EXAMPLE_STR_LEN];	/* for EXAMPLESTRING   */
  static oid  oid_ret[8];		/* for EXAMPLEOBJECTID */
  static long long_ret;			/* for everything else */
  
    /*
     * Before returning an answer, we need to check that the request
     *  refers to a valid instance of this object.  The utility routine
     *  'header_generic' can be used to do this for scalar objects.