Example #1
0
static int register_value_handlers(void)
{
	int i;

	for (i = 0; i < value_list.num_values; i++) {

		int result;
		netsnmp_handler_registration *value_reg;
		snmp_value_t *value = &(value_list.values[i]);

		value->val_oid_len = MAX_OID_LEN;
		if ((result =
		     convert_string_to_oid(value->oid_str, value->val_oid,
					   &value->val_oid_len)) != 0) {
			return -1;
		}

		DEBUG("Registering handle for stat name %s, ", value->stat_name);
		DEBUG_OID(value->val_oid, value->val_oid_len);

		value_reg = netsnmp_create_handler_registration(value->stat_name,
								value_handler,
								value->val_oid,
								value->val_oid_len, 0);
		netsnmp_register_instance(value_reg);
	}

	return 0;
}
Example #2
0
/**
 * \brief Initializes the deviceUserDesc module
 */
void
init_deviceUserDesc(void)
{
    const oid deviceUserDesc_oid[] = { 1,3,6,1,4,1,35990,3,1,1,10 };

    g_debug("deviceUserDesc initializing");
    netsnmp_register_instance(
        netsnmp_create_handler_registration("deviceUserDesc", handle_deviceUserDesc,
                               deviceUserDesc_oid, OID_LENGTH(deviceUserDesc_oid),
                               HANDLER_CAN_RWRITE
        ));
}
Example #3
0
int
netsnmp_register_watched_instance(netsnmp_handler_registration *reginfo,
                                  netsnmp_watcher_info         *watchinfo)
{
    netsnmp_mib_handler *whandler;

    whandler         = netsnmp_get_watcher_handler();
    whandler->myvoid = (void *)watchinfo;

    netsnmp_inject_handler(reginfo, whandler);
    return netsnmp_register_instance(reginfo);
}
/* Register OID handler for a sensor type  */
static int
reg_snmp_sensor_helper__(int sensor_type,
                         oid *reg_oid,
                         size_t oid_len,
                         int dev_idx)
{
    int ret = MIB_REGISTRATION_FAILED;

    Netsnmp_Node_Handler *handler = onlp_snmp_sensor_handler__;
    onlp_snmp_sensor_ctrl_t *ss_type = get_sensor_ctrl__(sensor_type);
    uint32_t col_cnt = ss_type->handler_cnt;
    char *table_name = ss_type->name;

    /* Use this to increase the column index in oid */
    u_long *oid_col = &reg_oid[oid_len - OID_SENSOR_COL_INDEX];

    /* Use this to increase the dev index of oid */
    reg_oid[oid_len - OID_SENSOR_DEV_INDEX] = dev_idx;

    snmp_log(LOG_DEBUG, "oid registrations: %s for dev_idx=%d",
             table_name, dev_idx);

    /*
     * Caller makes sure that this loop is run
     * since *oid_col starts as 1st col
     */
    for (; *oid_col < col_cnt; (*oid_col)++) {
        netsnmp_handler_registration *reg;

        if (!ss_type->handlers[*oid_col])
            continue;

        reg = netsnmp_create_handler_registration(table_name,
                                                  handler,
                                                  reg_oid,
                                                  oid_len,
                                                  HANDLER_CAN_RONLY);

        /* Ofad enables verbose/trace to see this */
        snmp_log(LOG_INFO, "registering handler for %s column %ld, index %d",
                 table_name, *oid_col, dev_idx);

        /* If reg is null, this returns error */
        ret = netsnmp_register_instance(reg);
        if(ret) {
            break;
        }
    }

    return ret;

}
Example #5
0
/** Initializes the hypervisor module */
void
init_vmInfo(void)
{
    const oid vmNumber_oid[] = { 1,3,6,1,2,1,VM_MIB_OID,1,2 };
    const oid vmTableLastChange_oid[] = { 1,3,6,1,2,1,VM_MIB_OID,1,3 };

    DEBUGMSGTL(("vmInfo", "Initializing\n"));

    netsnmp_register_instance(
        netsnmp_create_handler_registration("vmNumber",
                                            handle_vmNumber,
                                            vmNumber_oid,
                                            OID_LENGTH(vmNumber_oid),
                                            HANDLER_CAN_RONLY
            ));
    netsnmp_register_instance(
        netsnmp_create_handler_registration("vmTableLastChange",
                                            handle_vmTableLastChange,
                                            vmTableLastChange_oid,
                                            OID_LENGTH(vmTableLastChange_oid),
                                            HANDLER_CAN_RONLY
            ));
}
Example #6
0
void
init_delayed_instance(void)
{
    static oid      my_delayed_oid[] =
        { 1, 3, 6, 1, 4, 1, 8072, 2, 1, 2, 0 };
    /*
     * delayed handler test
     */
    netsnmp_handler_registration *my_test;

    my_test =
        netsnmp_create_handler_registration("delayed_instance_example",
                                            delayed_instance_handler,
                                            my_delayed_oid,
                                            OID_LENGTH(my_delayed_oid),
                                            HANDLER_CAN_RWRITE);

    netsnmp_register_instance(my_test);
}
Example #7
0
int
netsnmp_register_num_file_instance(const char *name,
                                   const oid * reg_oid, size_t reg_oid_len,
                                   const char *file_name, int asn_type, int mode,
                                   Netsnmp_Node_Handler * subhandler,
                                   const char *contextName)
{
    netsnmp_handler_registration *myreg;
    netsnmp_num_file_instance *nfi;

    if ((NULL == name) || (NULL == reg_oid) || (NULL == file_name)) {
        snmp_log(LOG_ERR, "bad parameter to netsnmp_register_num_file_instance\n");
        return MIB_REGISTRATION_FAILED;
    }

    nfi = SNMP_MALLOC_TYPEDEF(netsnmp_num_file_instance);
    if ((NULL == nfi) ||
        (NULL == (nfi->file_name = strdup(file_name)))) {
        snmp_log(LOG_ERR, "could not not allocate memory\n");
        if (NULL != nfi)
            free(nfi); /* SNMP_FREE overkill on local var */
        return MIB_REGISTRATION_FAILED;
    }

    nfi->refcnt = 1;
    myreg = get_reg(name, "file_num_handler", reg_oid, reg_oid_len, nfi,
                    mode, netsnmp_instance_num_file_handler,
                    subhandler, contextName);
    if (NULL == myreg) {
        netsnmp_num_file_instance_deref(nfi);
        return MIB_REGISTRATION_FAILED;
    }

    nfi->type = asn_type;

    if (HANDLER_CAN_RONLY == mode)
        return netsnmp_register_read_only_instance(myreg);

    return netsnmp_register_instance(myreg);
}
void
netsnmp_parse_override(const char *token, char *line)
{
    char           *cp;
    char            buf[SNMP_MAXBUF], namebuf[SNMP_MAXBUF];
    int             readwrite = 0;
    oid             oidbuf[MAX_OID_LEN];
    size_t          oidbuf_len = MAX_OID_LEN;
    int             type;
    override_data  *thedata;
    netsnmp_handler_registration *the_reg;

    cp = copy_nword(line, namebuf, sizeof(namebuf) - 1);
    if (strcmp(namebuf, "-rw") == 0) {
        readwrite = 1;
        cp = copy_nword(cp, namebuf, sizeof(namebuf) - 1);
    }

    if (!cp) {
        config_perror("no oid specified");
        return;
    }

    if (!snmp_parse_oid(namebuf, oidbuf, &oidbuf_len)) {
        config_perror("illegal oid");
        return;
    }
    cp = copy_nword(cp, buf, sizeof(buf) - 1);

    if (!cp && strcmp(buf, "null") != 0) {
        config_perror("no variable value specified");
        return;
    }

    {
        struct { const char* key; int value; } const strings[] = {
            { "counter", ASN_COUNTER },
            { "counter64", ASN_COUNTER64 },
            { "integer", ASN_INTEGER },
            { "ipaddress", ASN_IPADDRESS },
            { "nsap", ASN_NSAP },
            { "null", ASN_NULL },
            { "object_id", ASN_OBJECT_ID },
            { "octet_str", ASN_OCTET_STR },
            { "opaque", ASN_OPAQUE },
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
            { "opaque_counter64", ASN_OPAQUE_COUNTER64 },
            { "opaque_double", ASN_OPAQUE_DOUBLE },
            { "opaque_float", ASN_OPAQUE_FLOAT },
            { "opaque_i64", ASN_OPAQUE_I64 },
            { "opaque_u64", ASN_OPAQUE_U64 },
#endif
            { "timeticks", ASN_TIMETICKS },
            { "uinteger", ASN_GAUGE },
            { "unsigned", ASN_UNSIGNED },
            { NULL, 0 }
        }, * run;
        for(run = strings; run->key && strcasecmp(run->key, buf) < 0; ++run);
        if(run->key && strcasecmp(run->key, buf) == 0)
            type = run->value;
        else {
            config_perror("unknown type specified");
            return;
        }
    }

    if (cp)
        copy_nword(cp, buf, sizeof(buf) - 1);
    else
        buf[0] = 0;

    thedata = SNMP_MALLOC_TYPEDEF(override_data);
    if (!thedata) {
        config_perror("memory allocation failure");
        return;
    }
    thedata->type = type;

    switch (type) {
    case ASN_INTEGER:
        MALLOC_OR_DIE(sizeof(long));
        *((long *) thedata->value) = strtol(buf, NULL, 0);
        break;

    case ASN_COUNTER:
    case ASN_TIMETICKS:
    case ASN_UNSIGNED:
        MALLOC_OR_DIE(sizeof(u_long));
        *((u_long *) thedata->value) = strtoul(buf, NULL, 0);
        break;

    case ASN_OCTET_STR:
    case ASN_BIT_STR:
        if (buf[0] == '0' && buf[1] == 'x') {
            /*
             * hex 
             */
            thedata->value_len =
                hex_to_binary2((u_char *)(buf + 2), strlen(buf) - 2,
                               (char **) &thedata->value);
        } else {
            thedata->value = strdup(buf);
            thedata->value_len = strlen(buf);
        }
        break;

    case ASN_OBJECT_ID:
        read_config_read_objid(buf, (oid **) & thedata->value,
                               &thedata->value_len);
        break;

    case ASN_NULL:
        thedata->value_len = 0;
        break;

    default:
        SNMP_FREE(thedata);
        config_perror("illegal/unsupported type specified");
        return;
    }

    if (!thedata->value && thedata->type != ASN_NULL) {
        config_perror("memory allocation failure");
        free(thedata);
        return;
    }

    the_reg = SNMP_MALLOC_TYPEDEF(netsnmp_handler_registration);
    if (!the_reg) {
        config_perror("memory allocation failure");
        free(thedata);
        return;
    }

    the_reg->handlerName = strdup(namebuf);
    the_reg->priority = 255;
    the_reg->modes = (readwrite) ? HANDLER_CAN_RWRITE : HANDLER_CAN_RONLY;
    the_reg->handler =
        netsnmp_create_handler("override", override_handler);
    the_reg->rootoid = snmp_duplicate_objid(oidbuf, oidbuf_len);
    the_reg->rootoid_len = oidbuf_len;
    if (!the_reg->rootoid || !the_reg->handler || !the_reg->handlerName) {
        if (the_reg->handler)
            SNMP_FREE(the_reg->handler->handler_name);
        SNMP_FREE(the_reg->handler);
        SNMP_FREE(the_reg->handlerName);
        SNMP_FREE(the_reg);
        config_perror("memory allocation failure");
        free(thedata);
        return;
    }
    the_reg->handler->myvoid = thedata;

    if (netsnmp_register_instance(the_reg)) {
        config_perror("oid registration failed within the agent");
        SNMP_FREE(thedata->value);
        free(thedata);
        return;
    }
}
Example #9
0
void
init_testhandler(void)
{
    /*
     * we're registering at .1.2.3.4 
     */
    netsnmp_handler_registration *my_test;
    netsnmp_table_registration_info *table_info;
    u_long          ind1;
    netsnmp_table_data *table;
    netsnmp_table_data_set *table_set;
    netsnmp_table_row *row;

    DEBUGMSGTL(("testhandler", "initializing\n"));

    /*
     * basic handler test
     */
    netsnmp_register_handler(netsnmp_create_handler_registration
                             ("myTest", my_test_handler, my_test_oid, 4,
                              HANDLER_CAN_RONLY));

    /*
     * instance handler test
     */

    netsnmp_register_instance(netsnmp_create_handler_registration
                              ("myInstance", my_test_instance_handler,
                               my_instance_oid, 5, HANDLER_CAN_RWRITE));

    netsnmp_register_ulong_instance("myulong",
                                    my_data_ulong_instance, 4,
                                    &my_ulong, NULL);

    /*
     * table helper test
     */

    my_test = netsnmp_create_handler_registration("myTable",
                                                  my_test_table_handler,
                                                  my_table_oid, 4,
                                                  HANDLER_CAN_RONLY);
    if (!my_test)
        return;

    table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
    if (table_info == NULL)
        return;

    netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, ASN_INTEGER,
                                     0);
    table_info->min_column = 3;
    table_info->max_column = 3;
    netsnmp_register_table(my_test, table_info);

    /*
     * data table helper test
     */
    /*
     * we'll construct a simple table here with two indexes: an
     * integer and a string (why not).  It'll contain only one
     * column so the data pointer is merely the data in that
     * column. 
     */

    table = netsnmp_create_table_data("data_table_test");

    netsnmp_table_data_add_index(table, ASN_INTEGER);
    netsnmp_table_data_add_index(table, ASN_OCTET_STR);

    /*
     * 1 partridge in a pear tree 
     */
    row = netsnmp_create_table_data_row();
    ind1 = 1;
    netsnmp_table_row_add_index(row, ASN_INTEGER, &ind1, sizeof(ind1));
    netsnmp_table_row_add_index(row, ASN_OCTET_STR, "partridge",
                                strlen("partridge"));
    row->data = (void *) "pear tree";
    netsnmp_table_data_add_row(table, row);

    /*
     * 2 turtle doves 
     */
    row = netsnmp_create_table_data_row();
    ind1 = 2;
    netsnmp_table_row_add_index(row, ASN_INTEGER, &ind1, sizeof(ind1));
    netsnmp_table_row_add_index(row, ASN_OCTET_STR, "turtle",
                                strlen("turtle"));
    row->data = (void *) "doves";
    netsnmp_table_data_add_row(table, row);

    /*
     * we're going to register it as a normal table too, so we get the
     * automatically parsed column and index information 
     */
    table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
    if (table_info == NULL)
        return;

    netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER,
                                     ASN_OCTET_STR, 0);
    table_info->min_column = 3;
    table_info->max_column = 3;

    netsnmp_register_read_only_table_data
        (netsnmp_create_handler_registration
         ("12days", my_data_table_handler, my_data_table_oid, 4,
          HANDLER_CAN_RONLY), table, table_info);

}
Example #10
0
File: parse.c Project: ollyg/MIBjig
void m_parse (char *filename)
{
  /* Open File */
  int fd = open(filename, O_RDONLY);
  if (fd == -1) 
  { snmp_log(LOG_ERR, "m_parse failed to open %s: %s\n", filename, strerror(errno)); return; }
  size_t filesize = lseek(fd, 0, SEEK_END);
  void *source = mmap(0, filesize, PROT_READ, MAP_SHARED, fd, 0);
  if (source == MAP_FAILED)
  { snmp_log(LOG_ERR, "m_parse failed to mmap %s: %s\n", filename, strerror(errno)); return; }

  /* Compile the line-matching RegExp.
   * Matches lines like:
   *
   * .1.3.6.1.3.94.1.6.1.5.16.0.0.5.30.54.117.16.0.0.0.0.0.0.0.0 = INTEGER: 2
   *
   * Captures OID String, Type and Value
   */
  const char *error;
  int erroffset;
  pcre *re = pcre_compile("^((?:\\.[0-9]+)+) =(?: ([\\w-]+)\\:)? \"?(.*)$", PCRE_MULTILINE, &error, &erroffset, NULL);

  if (!re) { snmp_log(LOG_ERR, "m_parse failed to compile line-matching RE\n"); return; }

  /* Parse the mmap'd input file */
  int ovector[OVECCOUNT];
  ovector[0] = 0;
  ovector[1] = 0;
  while (1)
  {
    int options = 0; 
    int start_offset = ovector[1];

    int rc = pcre_exec(
      re,                   /* the compiled pattern */
      NULL,                 /* no extra data - we didn't study the pattern */
      source,               /* the subject string */
      filesize,             /* the length of the subject */
      start_offset,         /* starting offset in the subject */
      options,              /* options */
      ovector,              /* output vector for substring information */
      OVECCOUNT);           /* number of elements in the output vector */

    if (rc == PCRE_ERROR_NOMATCH)
    {
      if (options == 0) break;
      ovector[1] = start_offset + 1;
      continue;    /* Go round the loop again */
    }

    /* Other matching errors are not recoverable. */
    if (rc > 0)
    {
      /* Matched a walk line
       * 0=FullString 1(2)=OID 2(4)=Type 3(6)=Value
       */
      char *oid_str = string_at_vector(source, ovector, 2);
      char *type_str = string_at_vector(source, ovector, 4);
      char *value_str = string_at_vector(source, ovector, 6);

//      snmp_log(LOG_INFO, "OID='%s' TYPE='%s' VALUE='%s'\n", oid_str, type_str, value_str);

      /* Extract the oid from the string */
      size_t oid_len;
      oid *oid_array = oid_from_string(oid_str, &oid_len);

      /* Create a value struct from the strings */
      m_value *val = value_from_string(type_str, value_str);
      if (val)
      {
        /* Add the val to the values hashtable */
        i_hashtable_key *key = m_value_key(oid_str);
        i_hashtable_put(m_value_ht(), key, val);
        i_hashtable_key_free(key);

        /* Add SNMP Handler for the OID */
        //printf ("Registering value %s\n", oid_str);
        netsnmp_register_instance(
          netsnmp_create_handler_registration(oid_str, m_value_snmp_handler,
                                                   oid_array, oid_len, HANDLER_CAN_RONLY));
      }
    }
    else
    {
      /* Other matching error occurred */
      snmp_log(LOG_ERR, "m_parse other matching error occurred\n");
      pcre_free(re);    
      return;
    }
  }

  /* Clean up */
  pcre_free(re);




  /* Clean up */
  munmap(source, filesize);
  close(fd);


}
Example #11
0
void
init_demo_module_10(void)
{
	/*
	 * the OID at which to register the exampleData variable.
	 */
	static oid longRunScalar_oid[] =
	    {1, 3, 6, 1, 4, 1, 42, 2, 2, 4, 4, 10, 1, 1, 0};

	/*
	 * the OID at which to register the status variable.
	 */
	static oid status_oid[] =
	    {1, 3, 6, 1, 4, 1, 42, 2, 2, 4, 4, 10, 1, 2, 0};
	
	/*
	 * the OID at which to register the refreshTime variable.
	 */
	static oid refreshTime_oid[] =
	    {1, 3, 6, 1, 4, 1, 42, 2, 2, 4, 4, 10, 1, 3, 0};

	

	netsnmp_handler_registration *myreg;

	/*
	 * A debugging statement.  Run the agent with -Ddemo_module_10 to see
	 * the output of this debugging statement in /var/log/snmpd.log, by
	 * default. Use the -L option to write debugging output to the
	 * screen.
	 */
		DEBUGMSGTL(("demo_module_10", "Initializing\n"));
	/*
	 * Creates a read-only registration handler named longRunScalar,
	 * which calls the get_longRunScalar function to service snmp
	 * requests for the longRunScalar_oid object.  The OID_LENGTH
	 * argument calculates the length of the longRunScalar_oid.
	 */
	myreg = netsnmp_create_handler_registration
		       ("longRunScalar",
			get_longRunScalar,
			longRunScalar_oid,
			OID_LENGTH(longRunScalar_oid),
			HANDLER_CAN_RONLY);
	/*
	 * Register the instance and handler.
	 *
	 */
	netsnmp_register_read_only_instance(myreg);

	/*
	 * Creates a read/write registration handler named getStatus,
	 * which calls the get_status function to service snmp
	 * requests for the status_oid object.  The OID_LENGTH
	 * argument calculates the length of the status_oid.
	 */
	
	myreg = netsnmp_create_handler_registration
		       ("delayed_instance_handler",
			delayed_instance_handler,
			status_oid,
			OID_LENGTH(status_oid),
			HANDLER_CAN_RWRITE);
	/*
	 * Register the instance and handler.
	 *
	 */
	netsnmp_register_instance(myreg);


	/*
	 * Creates a read-only registration handler named getTimestamp,
	 * which calls the get_timestamp function to service snmp
	 * get requests for the timestamp_oid object.  The OID_LENGTH
	 * argument calculates the length of the timestamp_oid.
	 */
	
	myreg = netsnmp_create_handler_registration
		       ("getTimestamp",
			get_timestamp,
			refreshTime_oid,
			OID_LENGTH(refreshTime_oid),
			HANDLER_CAN_RONLY);
	/*
	 * Register the instance and handler.
	 *
	 */
	netsnmp_register_instance(myreg);

}
Example #12
0
void
init_demo_module_7(void)
{

	char *filexcon = "fileX";
	char *fileycon = "fileY";


	netsnmp_handler_registration *myreg1;
	int status;

	/*
	Create a read-only registration handler named filesize,
	which calls the get_filesize function to service snmp requests
	for the me1filesize_oid object.  The OID_LENGTH argument
	calculates the length of the me1filesize_oid. */
	DEBUGMSGTL(("demo_module_7", "Initializing\n"));
	myreg1 = netsnmp_create_handler_registration
					("filesize",
					get_filesize,
					me1filesize_oid,
					OID_LENGTH(me1filesize_oid),
					HANDLER_CAN_RONLY);

	myreg1->contextName = filexcon;
	status = netsnmp_register_read_only_instance(myreg1);
	DEBUGMSGTL(("demo_module_7", "init reg1 status %d:\n",  status));


	myreg1 = netsnmp_create_handler_registration
					("filesize",
					get_filesize,
					me1filesize_oid,
					OID_LENGTH(me1filesize_oid),
					HANDLER_CAN_RONLY);

	myreg1->contextName = fileycon;
	status = netsnmp_register_read_only_instance(myreg1);
	DEBUGMSGTL(("demo_module_7", "init reg2 status %d:\n",  status));


	/*
	Create a read-write registration handler named filesize,
	which calls the set_createContext function to service snmp requests
	for the me1createContext_oid object.  The OID_LENGTH argument
	calculates the length of the me1createContext_oid. */
	myreg1 = netsnmp_create_handler_registration
					("filesize",
					set_createContext,
					me1createContext_oid,
					OID_LENGTH(me1createContext_oid),
					HANDLER_CAN_RWRITE);

	status = netsnmp_register_instance(myreg1);
	DEBUGMSGTL(("filesize", "init reg3 status %d:\n",  status));

	/*
	Create a read-write registration handler named filesize,
	which calls the set_removeContext function to service snmp requests
	for the me1removeContext_oid object.  The OID_LENGTH argument
	calculates the length of the me1removeContext_oid. */
	myreg1 = netsnmp_create_handler_registration
					("filesize",
					set_removeContext,
					me1removeContext_oid,
					OID_LENGTH(me1removeContext_oid),
					HANDLER_CAN_RWRITE);

	status = netsnmp_register_instance(myreg1);
	DEBUGMSGTL(("demo_module_7", "init reg4 status %d:\n", status));
}