localgrp.c

非常不错的网管开发包

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal\@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY 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.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */

#include <config.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* minimal include directives */
#include "mibincl.h"
#include "util_funcs.h"
#include <AgentApi.hxx>
#include "VovidaSnmpUtil.h"
#include "localGrp.h"
#include "TrapAgentC.hxx"
#include "TrapAgent.hxx"
#include "Common.h"
#include "agent_trap.h"  // sink functions defined here

/* 
 * localGrp_variables_oid:
 *   this is the top level oid that we want to register under.  This
 *   is essentially a prefix, with the suffix appearing in the
 *   variable below.
 */


oid localGrp_variables_oid[] = { 1,3,6,1,4,1,5738,1,1,1 };
char startProcessName[SPRINT_MAX_LEN];
char stopProcessName[SPRINT_MAX_LEN];
char old_startProcessName[SPRINT_MAX_LEN];
char old_stopProcessName[SPRINT_MAX_LEN];
char in_startProcessName[SPRINT_MAX_LEN];
char in_stopProcessName[SPRINT_MAX_LEN];
char command[SPRINT_MAX_LEN];

int  in_startProcessNameSize, in_stopProcessNameSize;
int  new_debugLevel, old_debugLevel;
ulong ip_ulong;

static int true = 1, false = 0;


/* 
 * variable2 localGrp_variables:
 *   this variable defines function callbacks and type return information 
 *   for the localGrp mib section 
 */


#define   LOCALGRPSTARTPROCESSNAME  1
#define   LOCALGRPSTARTPROCESS  2
#define   LOCALGRPSTOPPROCESSNAME  3
#define   LOCALGRPSTOPPROCESS   4
#define   LOCALGRPDEBUGLEVEL   5
#define   TRAPSINKINDEX         8
#define   TRAPSINKIP            9
#define   LOCALGRPADDTRAPSINK   10
#define   LOCALGRPDELETETRAPSINK  11

struct variable4 localGrp_variables[] = {
/*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
  { LOCALGRPSTARTPROCESSNAME, ASN_OCTET_STR , RWRITE, var_localGrp, 1, { 1 } },
  { LOCALGRPSTARTPROCESS, ASN_INTEGER   , RWRITE, var_localGrp, 1, { 2 } },
  { LOCALGRPSTOPPROCESSNAME, ASN_OCTET_STR , RWRITE, var_localGrp, 1, { 3 } },
  { LOCALGRPSTOPPROCESS , ASN_INTEGER   , RWRITE, var_localGrp, 1, { 4 } },
  { LOCALGRPDEBUGLEVEL , ASN_INTEGER   , RWRITE, var_localGrp, 1, { 5 } },
  { TRAPSINKINDEX       , ASN_INTEGER   , RONLY , var_localGrpTrapSinkTable, 3, { 6,1,1 } },
  { TRAPSINKIP          , ASN_IPADDRESS , RONLY , var_localGrpTrapSinkTable, 3, { 6,1,2 } },
  { LOCALGRPADDTRAPSINK , ASN_IPADDRESS , RWRITE, var_localGrp, 1, { 7 } },
  { LOCALGRPDELETETRAPSINK, ASN_IPADDRESS , RWRITE, var_localGrp, 1, { 8 } },
};
/*    (L = length of the oidsuffix) */


/*
 * init_localGrp():
 *   Initialization routine.  This is called when the agent starts up.
 *   At a minimum, registration of your variables should take place here.
 */
void init_localGrp(void) {


  /* register ourselves with the agent to handle our mib tree */
  REGISTER_MIB("localGrp", localGrp_variables, variable4,
               localGrp_variables_oid);

  memset(startProcessName, 0, SPRINT_MAX_LEN);
  memset(stopProcessName, 0, SPRINT_MAX_LEN);

  /* place any other initialization junk you need here */
}


/*
 * var_localGrp():
 *   This function is called every time the agent gets a request for
 *   a scalar variable that might be found within your mib section
 *   registered above.  It is up to you to do the right thing and
 *   return the correct value.
 *     You should also correct the value of "var_len" if necessary.
 *
 *   Please see the documentation for more information about writing
 *   module extensions, and check out the examples in the examples
 *   and mibII directories.
 */
unsigned char *
var_localGrp(struct variable *vp, 
	     oid     *name, 
	     size_t  *length, 
	     int     exact, 
	     size_t  *var_len, 
	     WriteMethod **write_method)
{


    /* variables we may use later */
    static long long_ret;
    static unsigned char string[SPRINT_MAX_LEN];
    static oid objid[MAX_OID_LEN];
    static struct counter64 c64;
    ipcMessage message;
    int port, found, index;

    if (header_generic(vp,name,length,exact,var_len,write_method)
	== MATCH_FAILED )
	return 0;


    /* 
     * this is where we do the value assignments for the mib results.
   */
    switch(vp->magic) {


	case LOCALGRPSTARTPROCESSNAME:
	    *write_method = write_localGrpStartProcessName;
	    if (string && startProcessName) {
		memset(string, 0, SPRINT_MAX_LEN);
		strncpy(string, startProcessName, SPRINT_MAX_LEN);
	    } else {
		*string = 0;
	    }
	    *var_len = strlen(string);
	    return (unsigned char *) string;

	case LOCALGRPSTARTPROCESS:
	    *write_method = write_localGrpStartProcess;
	    long_ret = 0;
	    return (unsigned char *) &long_ret;

	case LOCALGRPSTOPPROCESSNAME:
	    *write_method = write_localGrpStopProcessName;
	    if (string && stopProcessName) {
		memset(string, 0, SPRINT_MAX_LEN);
		strncpy(string, stopProcessName, SPRINT_MAX_LEN);
	    } else {
		*string = 0;
	    }
	    *var_len = strlen(string);
	    return (unsigned char *) string;

	case LOCALGRPSTOPPROCESS:
	    *write_method = write_localGrpStopProcess;
	    long_ret = 0;
	    return (unsigned char *) &long_ret;
	case LOCALGRPDEBUGLEVEL:
	    *write_method = write_localGrpDebugLevel;
	    found = false;
	    index = TrapAgent_GetNextIndex((void *)trapAgent, 0, SERVER_Unknown);
	    port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);

	    while (found == false && port != 0) {

		if(ipcRequest((actionT)Get,
			      DebugLevel,
			      port,
			      &message) == voSuccess ) {
		    found = true;
		    memcpy(&long_ret, message.parm2, sizeof(ulong));
		} else {
		    index = TrapAgent_GetNextIndex((void *)trapAgent, index, SERVER_Unknown);
		    port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
		}
	    }
	    if (!found) 
		long_ret = -1;
	    return (unsigned char *) &long_ret;
	    
	case LOCALGRPADDTRAPSINK:
	    *write_method = write_localGrpAddTrapSink;
	    memset(&long_ret, 0, sizeof(ulong));
	    return (unsigned char *) &long_ret;
	    
	case LOCALGRPDELETETRAPSINK:
	    *write_method = write_localGrpDeleteTrapSink;
	    long_ret = 0;
	    return (unsigned char *) &long_ret;
	    
	default:
	    ERROR_MSG("");
    }
    return 0;
}


/*
 * var_localGrpTrapSinkTable():
 *   Handle this table separately from the scalar value case.
 *   The workings of this are basically the same as for var_localGrp above.
 */
unsigned char *
var_localGrpTrapSinkTable(struct variable *vp,
    	    oid     *name,
    	    size_t  *length,
    	    int     exact,
    	    size_t  *var_len,
    	    WriteMethod **write_method)
{


  /* variables we may use later */
  static long long_ret;
  static unsigned char string[SPRINT_MAX_LEN];
  static oid objid[MAX_OID_LEN];
  static struct counter64 c64;

  int tableSize, index;
  ulong *trapList = 0;


  /* 
   * This assumes that the table is a 'simple' table.
   *	See the implementation documentation for the meaning of this.
   *	You will need to provide the correct value for the TABLE_SIZE parameter
   *
   * If this table does not meet the requirements for a simple table,
   *	you will need to provide the replacement code yourself.
   *	Mib2c is not smart enough to write this for you.
   *    Again, see the implementation documentation for what is required.
   */

  tableSize = totalTrapSinks();
  if (header_simple_table(vp,name,length,exact,var_len,write_method, tableSize)
                                                == MATCH_FAILED )
    return 0;

  index = name[*length-1];

  /* 
   * this is where we do the value assignments for the mib results.
   */
  switch(vp->magic) {


    case TRAPSINKINDEX:
        
        long_ret = name[*length-1];
        return (unsigned char *) &long_ret;

    case TRAPSINKIP:
	// the IP address to return is the network byte order uLong
	// similar to the return value of gethostbyname

	// todo:  put a timer on this so we don't go throught this mess 
	// every time on an snmpwalk.
	trapList = (ulong *)calloc(1, tableSize*sizeof(ulong));
	if (!trapList)
	    return 0;
	if (!trapSinkList(trapList, tableSize) ) {
	    long_ret = 0;
	} else {
	    long_ret = trapList[index - 1];
	}
	free(trapList);
        return (unsigned char *) &long_ret;


    default:
      ERROR_MSG("");
  }
  return 0;
}





int
write_localGrpStartProcessName(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{
  static unsigned char string[SPRINT_MAX_LEN];
  static int size;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_OCTET_STR){
              fprintf(stderr, "write to localGrpStartProcessName not ASN_OCTET_STR\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(string)){
              fprintf(stderr,"write to localGrpStartProcessName: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
	  // this will avoid constantly checking for void var_val below.
	  if (!var_val || var_val_len == 0 ) {
	      fprintf(stderr, "write to localGrpStartProcessName: null value");
	      return SNMP_ERR_WRONGVALUE;
	  }          
	  break;
	  

        case RESERVE2:

	    size = var_val_len;
	    memset(string, 0, SPRINT_MAX_LEN);
	    strncpy(string, var_val, size);
	    
	    break;

        case FREE:
             /* Release any resources that have been allocated */
          break;


        case ACTION:
	    /* The variable has been stored in string for
	       you to use, and you have just been asked to do something with
	       it.  Note that anything done here must be reversable in the UNDO case */
	    memset(old_startProcessName, 0, SPRINT_MAX_LEN);
	    strcpy(old_startProcessName, startProcessName);
	    memset(startProcessName, 0, SPRINT_MAX_LEN);
	    strcpy(startProcessName, string);
	  break;

        case UNDO:
	    /* Back out any changes made in the ACTION case */
	    memset(startProcessName, 0, SPRINT_MAX_LEN);
	    strcpy(startProcessName, old_startProcessName);
	    break;

        case COMMIT:
	    /* Things are working well, so it's now safe to make the change
	       permanently.  Make sure that anything done here can't fail! */
	    break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_localGrpStartProcess(int      action,
            u_char   *var_val,
            u_char   var_val_type,
            size_t   var_val_len,
            u_char   *statP,
            oid      *name,
            size_t   name_len)
{

  switch ( action ) {
        case RESERVE1:
			/*
			 *  The only acceptable value is the integer 1
			 */
          if (var_val_type != ASN_INTEGER){
              fprintf(stderr, "write to localGrpStartProcess not ASN_INTEGER\n");
              return SNMP_ERR_WRONGTYPE;
          }
/*  maneri: the value of var_val doesn't work on solaris.  This will be fixed 
    after Asaigo 
*/
#ifdef __linux__
	  if  ( *var_val != 1 ) {
	      fprintf(stderr, "localGrpStartProcess:: set value must be \"1\"");
	      return SNMP_ERR_WRONGVALUE;
	  }
#endif
          break;