localgrp.c

非常不错的网管开发包

        case RESERVE2:

          break;


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


        case ACTION:
             /* The variable has been stored in long_ret 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 */
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          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! */

	        memset(command, 0, SPRINT_MAX_LEN);
#ifdef __linux__
		    sprintf(command,"/etc/rc.d/init.d/vocalstart restart %s",startProcessName);
#else
		    sprintf(command,"/etc/init.d/vocalstart restart %s",startProcessName);
#endif

	        if (system(command) == -1 ) {
		        fprintf(stderr,"localGrpStartProcess:: set failed");
	        }
	        break;
  }
  return SNMP_ERR_NOERROR;
}




int
write_localGrpStopProcessName(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];
  int size;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_OCTET_STR){
              fprintf(stderr, "write to localGrpStopProcessName not ASN_OCTET_STR\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(string)){
              fprintf(stderr,"write to localGrpStopProcessName: 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 localGrpStopProcessName: 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_stopProcessName, 0, SPRINT_MAX_LEN);
	    strcpy(old_stopProcessName, stopProcessName);
	    memset(stopProcessName, 0, SPRINT_MAX_LEN);
	    strcpy(stopProcessName, string);
	  break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
	    memset(stopProcessName, 0, SPRINT_MAX_LEN);
	    strcpy(stopProcessName, old_stopProcessName);
	    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_localGrpStopProcess(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 long *long_ret;
  int size;


  switch ( action ) {
        case RESERVE1:
			/*
			 *  The only acceptable value is the integer 1
			 */
          if (var_val_type != ASN_INTEGER){
              fprintf(stderr, "write to localGrpStopProcess 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, "localGrpStopProcess:: set value must be \"1\"");
	      return SNMP_ERR_WRONGVALUE;
	  }
#endif
          break;

        case RESERVE2:
          size = var_val_len;
          long_ret = (long *) var_val;


          break;


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


        case ACTION:
             /* The variable has been stored in long_ret 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 */
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
          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! */
	        memset(command, 0, SPRINT_MAX_LEN);

#ifdef __linux__
		sprintf(command,"/etc/rc.d/init.d/vocalstart stop %s",stopProcessName);
#else
		sprintf(command,"/etc/init.d/vocalstart stop %s",stopProcessName);
#endif

	    if (system(command) == -1 ) {
		fprintf(stderr,"localGrpStopProcess:: set failed");
	    }
          break;
  }
  return SNMP_ERR_NOERROR;
}



int
write_localGrpDebugLevel(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 long *long_ret;
    int size;
    ipcMessage message;
    int port, found, index;

    switch ( action ) {
    case RESERVE1:
	if (var_val_type != ASN_INTEGER){
	    fprintf(stderr, "write to localGrpDebugLevel not ASN_INTEGER\n");
	    return SNMP_ERR_WRONGTYPE;
	}
	if (var_val_len > sizeof(int)){
	    fprintf(stderr,"write to localGrpDebugLevel: bad length\n");
	    return SNMP_ERR_WRONGLENGTH;
	}
//	  if (var_val > LOG_DEBUG_STACK) {
	if (*((int *)var_val) >= 8) {
	    fprintf(stderr, "write to localGrpDebugLevel: bad debug level value\n");
	    return SNMP_ERR_WRONGVALUE;
	}
	break;


    case RESERVE2:
	new_debugLevel = *((int *) var_val);
	index =  TrapAgent_GetNextIndex((void *)trapAgent, 0, SERVER_Unknown);;
	found = false;
	port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
	while (found == false && port != 0) {

	    if(ipcRequest((actionT)Get,
			  DebugLevel,
			  port,
			  &message) == voSuccess ) {
		found = true;
		memcpy(&old_debugLevel, message.parm2, sizeof (int));
	    } else {
		index = TrapAgent_GetNextIndex((void *)trapAgent, index, SERVER_Unknown);
		port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
	    }
	}
	if (!found) 
	    return SNMP_ERR_RESOURCEUNAVAILABLE;

	break;


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


    case ACTION:
	/* The variable has been stored in long_ret 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 */
	    
	index = TrapAgent_GetNextIndex((void *)trapAgent, 0, SERVER_Unknown);
	port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
	while (port) {
	    ipcRequestFull((actionT)Set,
			   DebugLevel,
			   port,
			   &message,
			   &new_debugLevel,
			   sizeof(int));
	    index = TrapAgent_GetNextIndex((void *)trapAgent, index, SERVER_Unknown);
	    port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
	}

	break;

    case UNDO:
	/* Back out any changes made in the ACTION case */

	index = TrapAgent_GetNextIndex((void *)trapAgent, 0, SERVER_Unknown);
	port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
	while (port) {
	    ipcRequestFull((actionT)Set,
			   DebugLevel,
			   port,
			   &message,
			   &old_debugLevel,
			   sizeof(int));
	    index = TrapAgent_GetNextIndex((void *)trapAgent, index, SERVER_Unknown);
	    port = TrapAgent_GetStackPortFromIndex((void *)trapAgent, index);
	}
	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_localGrpAddTrapSink(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];
   int size;

  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_IPADDRESS){
              fprintf(stderr, "write to localGrpAddTrapSink not ASN_IPADDRESS\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(ulong)){
              fprintf(stderr,"write to localGrpAddTrapSink: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
          size = var_val_len;
	  memcpy(&ip_ulong, var_val, sizeof(ulong));
          break;


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


        case ACTION:
             /* The variable has been stored in ulong now do something with it.
             Note that anything done here must be reversable in the UNDO case */
	    if (add_v2_trap_sink(ip_ulong) == 0) {
		printf("localGrp:write_localGrpAddTrapSink:UNDO:  cannot add trap sink: %ul", ip_ulong);
	    }
          break;


        case UNDO:
	    /* Back out any changes made in the ACTION case */
	    if (remove_v2_trap_sink(ip_ulong) == 0) {
		printf("localGrp:write_localGrpAddTrapSink:UNDO:  cannot remove trap sink: %lu", ip_ulong);
	    } 
	    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_localGrpDeleteTrapSink(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];
  int size;


  switch ( action ) {
        case RESERVE1:
          if (var_val_type != ASN_IPADDRESS){
              fprintf(stderr, "write to localGrpDeleteTrapSink not ASN_IPADDRESS\n");
              return SNMP_ERR_WRONGTYPE;
          }
          if (var_val_len > sizeof(string)){
              fprintf(stderr,"write to localGrpDeleteTrapSink: bad length\n");
              return SNMP_ERR_WRONGLENGTH;
          }
          break;


        case RESERVE2:
	  memcpy(&ip_ulong, var_val, sizeof(ulong));
          size = var_val_len;
          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 */
	    if (remove_v2_trap_sink(ip_ulong) == 0) {
		printf("localGrp:write_localGrpDeleteTrapSink:UNDO:  cannot remove trap sink: %lu", ip_ulong);
	    } 
          break;


        case UNDO:
             /* Back out any changes made in the ACTION case */
	    if (add_v2_trap_sink(ip_ulong) == 0) {
		printf("localGrp:write_localGrpDeleteTrapSink:UNDO:  cannot add trap sink: %ul", ip_ulong);
	    }
          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;
}