snmpint.c

wm PNE 3.3 source code, running at more than vxworks6.x version.

	if ((set_state->pkt = SNMPTalk_Create_Request(SET_REQUEST_PDU, 
						      set_state->argc/2, 0, 0))
	    == 0) {

	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "No memory\n");
	    free(set_state);
	    return 1;
	    }

	parse_set_args(set_state);
	return(0);
    }
return(1);
}

static void
  hostname_tset_continue(struct sty *sty,
			 char *hostname,
                         ipaddr_t *hostaddr)
{
  if ((hostaddr == 0) || (hostaddr->type != IPV4)) {
    if (batch_mode)
      sty_putc(sty, '|');
    sty_printf(sty, "Can not locate host %s\n", set_static->argv[1]);
    
    SNMP_Free(set_static->pkt);
    free(set_static);
    command_next(sty);
  } else {
    SNMP_Bind_IP_Address(set_static->pkt, set_static->count /* index */,
                         set_static->oid_len, set_static->oid_buf,
                         (OCTET_T *)&(hostaddr->addr));
    set_static->argc -= 3;
    set_static->argv += 3;
    set_static->count += 1;
    set_static->sty = sty;
    parse_tset_args(set_static); /* continue building the set packet */
  }
}

/* Parses the arguments to the TSET command. */
static void
  parse_tset_args(struct set_op *set_state)
{
  char  *err_msg;
  
  while (set_state->argc) {
    set_state->oid_len = string2oid(set_state->argv[0], set_state->oid_buf,
                                    sizeof(set_state->oid_buf)/sizeof(OIDC_T));
    if (set_state->oid_len == 0) {
      if (batch_mode)
	sty_putc(set_state->sty, '|');
      sty_printf(set_state->sty, "No mib entry `%s'\n", set_state->argv[0]);
      goto bug_out;
    }
    else if (set_state->oid_len > sizeof(set_state->oid_buf)/sizeof(OIDC_T)) {
      if (batch_mode)
	sty_putc(set_state->sty, '|');
      sty_puts(set_state->sty, "Internal buffer exceeded, OID too long.\n");
      goto bug_out;
    }
    
#define STRICMP_LEADING(str, arg) STRNICMP(str, arg, STRLEN(arg))
    
    if (STRICMP_LEADING("number", set_state->argv[1]) == 0)
      SNMP_Bind_Integer(set_state->pkt, set_state->count /* index */,
			set_state->oid_len, set_state->oid_buf,
			atol(set_state->argv[2]));
    
    /* We can only use v2 types if they are installed */
#if (ENVOY_USE_V2_TYPES)
else if (STRICMP_LEADING("counter64", set_state->argv[1]) == 0) {
  if (sscanf(set_state->argv[2], "%ld:%ld", &(set_state->high),
	     &(set_state->low)) != 2) {
    sty_puts(set_state->sty,
	     "Counter 64 needs 2 arguments high:low\n");
    goto bug_out;
  }
  SNMP_Bind_64_Unsigned_Integer(set_state->pkt, set_state->count,
				set_state->oid_len, set_state->oid_buf,
				(OCTET_T)VT_COUNTER64,
				set_state->high, set_state->low);
}
#else  /* (ENVOY_USE_V2_TYPES) */
    /* If the version 2 types aren't installed, mention that to the user */
    else if (STRICMP_LEADING("counter64", set_state->argv[1]) == 0) {
      if (batch_mode)
	sty_putc(set_state->sty, '|');
      sty_puts(set_state->sty,
	       "V2 type requested but v2 type code isn't installed\n");
      goto bug_out;
    }
#endif /* (ENVOY_USE_V2_TYPES) */
    
    else if (STRICMP_LEADING("string", set_state->argv[1]) == 0)
      SNMP_Bind_String(set_state->pkt, set_state->count /* index */,
		       set_state->oid_len, set_state->oid_buf,
		       (OCTET_T)VT_STRING,
		       STRLEN(set_state->argv[2]),
		       (OCTET_T *)set_state->argv[2], 1 /* copy */);
    else if (STRICMP_LEADING("ipaddress", set_state->argv[1]) == 0) {
      set_static = set_state;

      md_hostname_to_addr(set_state->sty, set_state->argv[2],
			  hostname_tset_continue);
      return;
    }
    else if (STRICMP_LEADING("counter", set_state->argv[1]) == 0)
      SNMP_Bind_Unsigned_Integer(set_state->pkt, set_state->count /*index */,
				 set_state->oid_len, set_state->oid_buf,
				 (OCTET_T)VT_COUNTER,
				 (UINT_32_T)atol(set_state->argv[2]));
    else if (STRICMP_LEADING("gauge", set_state->argv[1]) == 0)
      SNMP_Bind_Unsigned_Integer(set_state->pkt, set_state->count /*index */,
				 set_state->oid_len, set_state->oid_buf,
				 (OCTET_T)VT_GAUGE,
				 (UINT_32_T)atol(set_state->argv[2]));
    else if (STRICMP_LEADING("timeticks", set_state->argv[1]) == 0)
      SNMP_Bind_Unsigned_Integer(set_state->pkt, set_state->count /*index */,
				 set_state->oid_len, set_state->oid_buf,
				 (OCTET_T)VT_TIMETICKS,
				 (UINT_32_T)atol(set_state->argv[2]));
    else {
      if (batch_mode)
	sty_putc(set_state->sty, '|');
      sty_printf(set_state->sty,
		 "Unknown type %s, try:\n", set_state->argv[1]);
      if (!batch_mode) {
	sty_puts(set_state->sty,
		 "  number, string, ipaddress, counter, gauge, or timeticks\n");
	sty_puts(set_state->sty, "Or if v2 is installed counter64\n");
      }
      goto bug_out;
    }
    
    set_state->argc -= 3;
    set_state->argv += 3;
    set_state->count += 1;
  }
  
  err_msg = snmp_send_rec(set_state->sty, set_state->pkt,
			  &dest_addr, response_print, error_response);
  if (err_msg != 0) {
    if (batch_mode)
      sty_putc(set_state->sty, '|');
    sty_printf(set_state->sty, "%s\n", err_msg);
    command_next(set_state->sty);
  }
  else
    free(set_state);
  return;
  
 bug_out:
  SNMP_Free(set_state->pkt);
  free(set_state);
  command_next(set_state->sty);
}

/*
 * Implements the TSET command.
 */
boolean_t
  do_tset(struct sty        *sty,
	  enum   help_level  help,
	         int         argc,
	         char       *argv[])
{
struct set_op *set_state;
switch (help) {
    case help_short:
	sty_puts(sty, "\
tset <variable> <type> <value> - set a MIB variable (specifying type)\n");
	break;

    case help_long:
	sty_puts(sty, "\
The 'tset <variable> <type> <value>' command is like the\n\
'set' command but allows you to specify the type to use.  Types are:\n\
   number\n\
   string\n\
   ipaddress\n\
   counter\n\
   gauge\n\
   timeticks\n");
	break;

    case help_none:
	if (dest_addr.type == IPNONE) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty,
		     "Need to set a destination before using this command.\n");
	    return 1;
	    }

	argc -= 1;
	argv += 1;
	if (argc < 3) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty,
		     "Need to specify MIB variables to SET and types and values.\n");
	    if (!batch_mode)
	        sty_puts(sty, " Usage: tset { variable type value } ...\n");
	    return 1;
	    }

	if ((argc % 3) != 0) {        /* if not a multiple of 3 */
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty,
		     "Need matching number of variables, type, and values.\n");
	    return 1;
	    }

	set_state = (struct set_op *)malloc(sizeof(struct set_op));
	if (set_state == 0) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "No memory.\n");
	    return 1;
	    }
	set_state->argc = argc;
	set_state->argv = argv;
	set_state->count = 0;
	set_state->sty = sty;

	if ((set_state->pkt = SNMPTalk_Create_Request(SET_REQUEST_PDU, 
						      set_state->argc/3, 0, 0))
	    == 0) {

	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "No memory\n");
	    free(set_state);
	    return(1);
	    }

	parse_tset_args(set_state);
	return(0);
    }
return(1);
}

/*
 * Implements the GET command.
 */
boolean_t
  do_get(struct sty        *sty,
	 enum   help_level  help,
	        int         argc,
	        char       *argv[])
{
SNMP_PKT_T  *xmit_pkt;
OIDC_T      oid_buf[40];
int         oid_len;
char        *err_msg;
int         vb_count;

switch (help) {
    case help_short:
	sty_puts(sty, "get <variable> ... - get MIB variables\n");
	break;

    case help_long:
	sty_puts(sty, "\
The 'get <variable> ...' command does an SNMP GET of <variable>\n\
and prints the result.  If <variable> is not in the MIB and the\n\
returned value is type <octet string> then it is printed as colon\n\
separated hex bytes if any of the bytes are not printable, otherwise\n\
it is printed as a character string.\n");
	break;

    case help_none:
	if (dest_addr.type == IPNONE) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "Need to specify destination first\n");
	    return 1;
	    }

	if (argc == 1) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "Need to specify MIB variable to GET\n");
	    return 1;
	    }

	argc -= 1;                  /* remove the command name */

	xmit_pkt = SNMPTalk_Create_Request(GET_REQUEST_PDU, argc, 0, 0);
	if (xmit_pkt == 0) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "Error creating SNMP request\n");
	    return 1;
	    }

	for (vb_count = 0; vb_count < argc; vb_count++) {
	    oid_len = string2oid(argv[vb_count+1], oid_buf,
				 sizeof(oid_buf)/sizeof(OIDC_T));
	    if (oid_len == 0) {
	        if (batch_mode)
		    sty_putc(sty, '|');
		sty_printf(sty, "No mib entry `%s'\n", argv[vb_count+1]);
		SNMP_Free(xmit_pkt);
		return 1;
	        }
	    else if (oid_len > sizeof(oid_buf)/sizeof(OIDC_T)) {
	        if (batch_mode)
		    sty_putc(sty, '|');
		sty_puts(sty, "Internal buffer exceeded, OID too long.\n");
		SNMP_Free(xmit_pkt);
		return 1;
	        }

	    /* Build the name for an object with the appropriate OID */
	    SNMP_Bind_Null(xmit_pkt, vb_count, oid_len, oid_buf);
	    }

	err_msg = snmp_send_rec(sty, xmit_pkt, &dest_addr, response_print,
				error_response);
	if (err_msg) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_printf(sty, "%s\n", err_msg);
	    return 1;
	    }
	return(0);
    }
return(1);
}

/*
 * Implements the NEXT command.
 */
boolean_t
  do_next(struct sty        *sty,
	  enum   help_level  help,
	         int         argc,
	         char       *argv[])
{
SNMP_PKT_T  *xmit_pkt;
OIDC_T      oid_buf[40];
int         oid_len;
char        *err_msg;
int         vb_count;

switch (help) {
    case help_short:
	sty_puts(sty,
		 "next <variable> ... - do a getnext on a MIB variable\n");
	break;

    case help_long:
	sty_puts(sty, "\
The 'next <variable> ...' command does an SNMP GET NEXT of\n\
<variable> and prints the result.  If <variable> is not in\n\
the MIB and the returned value is type <octet string> then\n\
it is printed as colon separated hex bytes if any of the bytes\n\
are not printable, otherwise it is printed as a character string.\n");
	break;

    case help_none:
	if (dest_addr.type == IPNONE) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "Need to specify destination first\n");
	    return 1;
	    }

	if (argc == 1) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "Need to specify MIB variable to NEXT\n");
	    return 1;
	    }

	argc -= 1;                  /* remove the command name */

	xmit_pkt = SNMPTalk_Create_Request(GET_NEXT_REQUEST_PDU, argc, 0, 0);
	if (xmit_pkt == 0) {
	    if (batch_mode)
	        sty_putc(sty, '|');
	    sty_puts(sty, "Error creating SNMP request\n");
	    return 1;
	    }

	for (vb_count = 0; vb_count < argc; vb_count++) {
	    oid_len = string2oid(argv[vb_count+1], oid_buf,
				 sizeof(oid_buf)/sizeof(OIDC_T));
	    if (oid_len == 0) {
	        if (batch_mode)
		    sty_putc(sty, '|');
		sty_printf(sty, "No mib entry `%s'\n", argv[vb_count+1]);
		SNMP_Free(xmit_pkt);
		return 1;
	        }
	    else if (oid_len > sizeof(oid_buf)/sizeof(OIDC_T)) {
	        if (batch_mode)
		    sty_putc(sty, '|');
		sty_puts(sty, "Internal buffer exceeded, OID too long.\n");
		SNMP_Free(xmit_pkt);
		return 1;
	        }

	    /* Build the name for an object with the appropriate OID */
	    SNMP_Bind_Null(xmit_pkt, vb_count, oid_len, oid_buf);
	    }

	err_msg = snmp_send_rec(sty, xmit_pkt, &dest_addr, response_print,
				error_response);