X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsnmp.c;h=4d6e76947a37ef983c7180debff49dfc1c25f6c0;hb=074b4980bc75bea6826e6a38dcc6e193a721b2a8;hp=0989143e9f66ef30bbe0e9bb16f9d26715b7bc36;hpb=cf3523f2908c911f30c708822fe5c61f0d68f1f8;p=collectd.git diff --git a/src/snmp.c b/src/snmp.c index 0989143e..4d6e7694 100644 --- a/src/snmp.c +++ b/src/snmp.c @@ -51,8 +51,11 @@ struct data_definition_s char *type; /* used to find the data_set */ int is_table; instance_t instance; + char *instance_prefix; oid_t *values; int values_len; + double scale; + double shift; struct data_definition_s *next; }; typedef struct data_definition_s data_definition_t; @@ -124,6 +127,7 @@ static pthread_cond_t host_cond = PTHREAD_COND_INITIALIZER; * ! +-> csnmp_config_add_data_type * ! +-> csnmp_config_add_data_table * ! +-> csnmp_config_add_data_instance + * ! +-> csnmp_config_add_data_instance_prefix * ! +-> csnmp_config_add_data_values * +-> csnmp_config_add_host * +-> csnmp_config_add_host_address @@ -149,9 +153,7 @@ static int csnmp_config_add_data_type (data_definition_t *dd, oconfig_item_t *ci return (-1); } - if (dd->type != NULL) - free (dd->type); - + sfree (dd->type); dd->type = strdup (ci->values[0].value.string); if (dd->type == NULL) return (-1); @@ -196,12 +198,37 @@ static int csnmp_config_add_data_instance (data_definition_t *dd, oconfig_item_t else { /* Instance is a simple string */ - strncpy (dd->instance.string, ci->values[0].value.string, DATA_MAX_NAME_LEN - 1); + sstrncpy (dd->instance.string, ci->values[0].value.string, + sizeof (dd->instance.string)); } return (0); } /* int csnmp_config_add_data_instance */ +static int csnmp_config_add_data_instance_prefix (data_definition_t *dd, + oconfig_item_t *ci) +{ + if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("snmp plugin: `InstancePrefix' needs exactly one string argument."); + return (-1); + } + + if (!dd->is_table) + { + WARNING ("snmp plugin: data %s: InstancePrefix is ignored when `Table' " + "is set to `false'.", dd->name); + return (-1); + } + + sfree (dd->instance_prefix); + dd->instance_prefix = strdup (ci->values[0].value.string); + if (dd->instance_prefix == NULL) + return (-1); + + return (0); +} /* int csnmp_config_add_data_instance_prefix */ + static int csnmp_config_add_data_values (data_definition_t *dd, oconfig_item_t *ci) { int i; @@ -219,8 +246,8 @@ static int csnmp_config_add_data_values (data_definition_t *dd, oconfig_item_t * return (-1); } - if (dd->values != NULL) - free (dd->values); + sfree (dd->values); + dd->values_len = 0; dd->values = (oid_t *) malloc (sizeof (oid_t) * ci->values_num); if (dd->values == NULL) return (-1); @@ -245,6 +272,34 @@ static int csnmp_config_add_data_values (data_definition_t *dd, oconfig_item_t * return (0); } /* int csnmp_config_add_data_instance */ +static int csnmp_config_add_data_shift (data_definition_t *dd, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("snmp plugin: The `Scale' config option needs exactly one number argument."); + return (-1); + } + + dd->shift = ci->values[0].value.number; + + return (0); +} /* int csnmp_config_add_data_shift */ + +static int csnmp_config_add_data_scale (data_definition_t *dd, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("snmp plugin: The `Scale' config option needs exactly one number argument."); + return (-1); + } + + dd->scale = ci->values[0].value.number; + + return (0); +} /* int csnmp_config_add_data_scale */ + static int csnmp_config_add_data (oconfig_item_t *ci) { data_definition_t *dd; @@ -269,6 +324,8 @@ static int csnmp_config_add_data (oconfig_item_t *ci) free (dd); return (-1); } + dd->scale = 1.0; + dd->shift = 0.0; for (i = 0; i < ci->children_num; i++) { @@ -281,8 +338,14 @@ static int csnmp_config_add_data (oconfig_item_t *ci) status = csnmp_config_add_data_table (dd, option); else if (strcasecmp ("Instance", option->key) == 0) status = csnmp_config_add_data_instance (dd, option); + else if (strcasecmp ("InstancePrefix", option->key) == 0) + status = csnmp_config_add_data_instance_prefix (dd, option); else if (strcasecmp ("Values", option->key) == 0) status = csnmp_config_add_data_values (dd, option); + else if (strcasecmp ("Shift", option->key) == 0) + status = csnmp_config_add_data_shift (dd, option); + else if (strcasecmp ("Scale", option->key) == 0) + status = csnmp_config_add_data_scale (dd, option); else { WARNING ("snmp plugin: Option `%s' not allowed here.", option->key); @@ -314,6 +377,7 @@ static int csnmp_config_add_data (oconfig_item_t *ci) if (status != 0) { sfree (dd->name); + sfree (dd->instance_prefix); sfree (dd->values); sfree (dd); return (-1); @@ -628,7 +692,8 @@ static void csnmp_host_open_session (host_definition_t *host) } } /* void csnmp_host_open_session */ -static value_t csnmp_value_list_to_value (struct variable_list *vl, int type) +static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, + double scale, double shift) { value_t ret; uint64_t temp = 0; @@ -643,14 +708,18 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type) || (vl->type == ASN_GAUGE)) { temp = (uint32_t) *vl->val.integer; - DEBUG ("snmp plugin: Parsed int32 value is %llu.", temp); + DEBUG ("snmp plugin: Parsed int32 value is %"PRIu64".", temp); } else if (vl->type == ASN_COUNTER64) { temp = (uint32_t) vl->val.counter64->high; temp = temp << 32; temp += (uint32_t) vl->val.counter64->low; - DEBUG ("snmp plugin: Parsed int64 value is %llu.", temp); + DEBUG ("snmp plugin: Parsed int64 value is %"PRIu64".", temp); + } + else if (vl->type == ASN_OCTET_STR) + { + /* We'll handle this later.. */ } else { @@ -658,7 +727,51 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type) defined = 0; } - if (type == DS_TYPE_COUNTER) + if (vl->type == ASN_OCTET_STR) + { + char *endptr; + + endptr = NULL; + if (vl->val.string != NULL) + { + char string[64]; + size_t string_length; + + string_length = sizeof (string) - 1; + if (vl->val_len < string_length) + string_length = vl->val_len; + + /* The strings we get from the Net-SNMP library may not be null + * terminated. That is why we're using `membpy' here and not `strcpy'. + * `string_length' is set to `vl->val_len' which holds the length of the + * string. -octo */ + memcpy (string, vl->val.string, string_length); + string[string_length] = 0; + + if (type == DS_TYPE_COUNTER) + { + ret.counter = (counter_t) strtoll (string, &endptr, /* base = */ 0); + DEBUG ("snmp plugin: csnmp_value_list_to_value: String to counter: %s -> %llu", + string, (unsigned long long) ret.counter); + } + else if (type == DS_TYPE_GAUGE) + { + ret.gauge = (gauge_t) strtod (string, &endptr); + DEBUG ("snmp plugin: csnmp_value_list_to_value: String to gauge: %s -> %g", + string, (double) ret.gauge); + } + } + + /* Check if an error occurred */ + if ((vl->val.string == NULL) || (endptr == (char *) vl->val.string)) + { + if (type == DS_TYPE_COUNTER) + ret.counter = 0; + else if (type == DS_TYPE_GAUGE) + ret.gauge = NAN; + } + } + else if (type == DS_TYPE_COUNTER) { ret.counter = temp; } @@ -666,12 +779,142 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type) { ret.gauge = NAN; if (defined != 0) - ret.gauge = temp; + ret.gauge = (scale * temp) + shift; } return (ret); } /* value_t csnmp_value_list_to_value */ +/* Returns true if all OIDs have left their subtree */ +static int csnmp_check_res_left_subtree (const host_definition_t *host, + const data_definition_t *data, + struct snmp_pdu *res) +{ + struct variable_list *vb; + int num_checked; + int num_left_subtree; + int i; + + vb = res->variables; + if (vb == NULL) + return (-1); + + num_checked = 0; + num_left_subtree = 0; + + /* check all the variables and count how many have left their subtree */ + for (vb = res->variables, i = 0; + (vb != NULL) && (i < data->values_len); + vb = vb->next_variable, i++) + { + num_checked++; + if (snmp_oid_ncompare (data->values[i].oid, + data->values[i].oid_len, + vb->name, vb->name_length, + data->values[i].oid_len) != 0) + num_left_subtree++; + } + + /* check if enough variables have been returned */ + if (i < data->values_len) + { + ERROR ("snmp plugin: host %s: Expected %i variables, but got only %i", + host->name, data->values_len, i); + return (-1); + } + + if (data->instance.oid.oid_len > 0) + { + if (vb == NULL) + { + ERROR ("snmp plugin: host %s: Expected one more variable for " + "the instance..", host->name); + return (-1); + } + + num_checked++; + if (snmp_oid_ncompare (data->instance.oid.oid, + data->instance.oid.oid_len, + vb->name, vb->name_length, + data->instance.oid.oid_len) != 0) + num_left_subtree++; + } + + DEBUG ("snmp plugin: csnmp_check_res_left_subtree: %i of %i variables have " + "left their subtree", + num_left_subtree, num_checked); + if (num_left_subtree >= num_checked) + return (1); + return (0); +} /* int csnmp_check_res_left_subtree */ + +static int csnmp_instance_list_add (csnmp_list_instances_t **head, + csnmp_list_instances_t **tail, + const struct snmp_pdu *res) +{ + csnmp_list_instances_t *il; + struct variable_list *vb; + + /* Set vb on the last variable */ + for (vb = res->variables; + (vb != NULL) && (vb->next_variable != NULL); + vb = vb->next_variable) + /* do nothing */; + if (vb == NULL) + return (-1); + + il = (csnmp_list_instances_t *) malloc (sizeof (csnmp_list_instances_t)); + if (il == NULL) + { + ERROR ("snmp plugin: malloc failed."); + return (-1); + } + il->subid = vb->name[vb->name_length - 1]; + il->next = NULL; + + /* Get instance name */ + if ((vb->type == ASN_OCTET_STR) || (vb->type == ASN_BIT_STR)) + { + char *ptr; + size_t instance_len; + + memset (il->instance, 0, sizeof (il->instance)); + instance_len = sizeof (il->instance) - 1; + if (instance_len > vb->val_len) + instance_len = vb->val_len; + + sstrncpy (il->instance, (char *) ((vb->type == ASN_OCTET_STR) + ? vb->val.string + : vb->val.bitstring), + instance_len + 1); + + for (ptr = il->instance; *ptr != '\0'; ptr++) + { + if ((*ptr > 0) && (*ptr < 32)) + *ptr = ' '; + else if (*ptr == '/') + *ptr = '_'; + } + DEBUG ("snmp plugin: il->instance = `%s';", il->instance); + } + else + { + value_t val = csnmp_value_list_to_value (vb, DS_TYPE_COUNTER, 1.0, 0.0); + ssnprintf (il->instance, sizeof (il->instance), + "%llu", val.counter); + } + + /* TODO: Debugging output */ + + if (*head == NULL) + *head = il; + else + (*tail)->next = il; + *tail = il; + + return (0); +} /* int csnmp_instance_list_add */ + static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *data, csnmp_list_instances_t *instance_list, csnmp_table_values_t **value_table) @@ -683,6 +926,8 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat csnmp_table_values_t **value_table_ptr; int i; + oid subid; + int have_more; ds = plugin_get_ds (data->type); if (!ds) @@ -692,6 +937,8 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat } assert (ds->ds_num == data->values_len); + instance_list_ptr = instance_list; + value_table_ptr = (csnmp_table_values_t **) malloc (sizeof (csnmp_table_values_t *) * data->values_len); if (value_table_ptr == NULL) @@ -703,47 +950,100 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat vl.values = (value_t *) malloc (sizeof (value_t) * vl.values_len); if (vl.values == NULL) { + ERROR ("snmp plugin: malloc failed."); sfree (value_table_ptr); return (-1); } - strncpy (vl.host, host->name, sizeof (vl.host)); - vl.host[sizeof (vl.host) - 1] = '\0'; - strcpy (vl.plugin, "snmp"); + sstrncpy (vl.host, host->name, sizeof (vl.host)); + sstrncpy (vl.plugin, "snmp", sizeof (vl.plugin)); vl.interval = host->interval; vl.time = time (NULL); - for (instance_list_ptr = instance_list; - instance_list_ptr != NULL; - instance_list_ptr = instance_list_ptr->next) + subid = 0; + have_more = 1; + + while (have_more != 0) { - strncpy (vl.type_instance, instance_list_ptr->instance, sizeof (vl.type_instance)); - vl.type_instance[sizeof (vl.type_instance) - 1] = '\0'; + if (instance_list != NULL) + { + while ((instance_list_ptr != NULL) + && (instance_list_ptr->subid < subid)) + instance_list_ptr = instance_list_ptr->next; + + if (instance_list_ptr == NULL) + { + have_more = 0; + continue; + } + else if (instance_list_ptr->subid > subid) + { + subid = instance_list_ptr->subid; + continue; + } + } /* if (instance_list != NULL) */ for (i = 0; i < data->values_len; i++) { while ((value_table_ptr[i] != NULL) - && (value_table_ptr[i]->subid < instance_list_ptr->subid)) + && (value_table_ptr[i]->subid < subid)) value_table_ptr[i] = value_table_ptr[i]->next; - if ((value_table_ptr[i] == NULL) - || (value_table_ptr[i]->subid != instance_list_ptr->subid)) - break; - vl.values[i] = value_table_ptr[i]->value; - } /* for (data->values_len) */ - /* If the for-loop was aborted early, not all subid's match. */ + if (value_table_ptr[i] == NULL) + { + have_more = 0; + break; + } + else if (value_table_ptr[i]->subid > subid) + { + subid = value_table_ptr[i]->subid; + break; + } + } /* for (i = 0; i < columns; i++) */ + /* The subid has been increased - start scanning from the beginning + * again.. */ if (i < data->values_len) - { - DEBUG ("snmp plugin: host = %s; data = %s; i = %i; " - "Skipping SUBID %i", - host->name, data->name, i, instance_list_ptr->subid); continue; + + /* if we reach this line, all value_table_ptr[i] are non-NULL and are set + * to the same subid. instance_list_ptr is either NULL or points to the + * same subid, too. */ +#if COLLECT_DEBUG + for (i = 1; i < data->values_len; i++) + { + assert (value_table_ptr[i] != NULL); + assert (value_table_ptr[i-1]->subid == value_table_ptr[i]->subid); + } + assert ((instance_list_ptr == NULL) + || (instance_list_ptr->subid == value_table_ptr[0]->subid)); +#endif + + sstrncpy (vl.type, data->type, sizeof (vl.type)); + + { + char temp[DATA_MAX_NAME_LEN]; + + if (instance_list_ptr == NULL) + ssnprintf (temp, sizeof (temp), "%u", (uint32_t) subid); + else + sstrncpy (temp, instance_list_ptr->instance, sizeof (temp)); + + if (data->instance_prefix == NULL) + sstrncpy (vl.type_instance, temp, sizeof (vl.type_instance)); + else + ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s%s", + data->instance_prefix, temp); } + for (i = 0; i < data->values_len; i++) + vl.values[i] = value_table_ptr[i]->value; + /* If we get here `vl.type_instance' and all `vl.values' have been set */ - plugin_dispatch_values (data->type, &vl); - } /* for (instance_list) */ + plugin_dispatch_values (&vl); + + subid++; + } /* while (have_more != 0) */ sfree (vl.values); sfree (value_table_ptr); @@ -799,16 +1099,22 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) oid_list_len = data->values_len + 1; oid_list = (oid_t *) malloc (sizeof (oid_t) * (oid_list_len)); if (oid_list == NULL) + { + ERROR ("snmp plugin: csnmp_read_table: malloc failed."); return (-1); - memcpy (oid_list, &data->instance.oid, sizeof (oid_t)); - for (i = 0; i < data->values_len; i++) - memcpy (oid_list + (i + 1), data->values + i, sizeof (oid_t)); + } + memcpy (oid_list, data->values, data->values_len * sizeof (oid_t)); + if (data->instance.oid.oid_len > 0) + memcpy (oid_list + data->values_len, &data->instance.oid, sizeof (oid_t)); + else + oid_list_len--; /* Allocate the `value_table' */ value_table = (csnmp_table_values_t **) malloc (sizeof (csnmp_table_values_t *) * 2 * data->values_len); if (value_table == NULL) { + ERROR ("snmp plugin: csnmp_read_table: malloc failed."); sfree (oid_list); return (-1); } @@ -821,8 +1127,6 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) status = 0; while (status == 0) { - csnmp_list_instances_t *il; - req = snmp_pdu_create (SNMP_MSG_GETNEXT); if (req == NULL) { @@ -837,10 +1141,6 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) res = NULL; status = snmp_sess_synch_response (host->sess_handle, req, &res); - if (req != NULL) - snmp_free_pdu (req); - req = NULL; - if ((status != STAT_SUCCESS) || (res == NULL)) { char *errstr = NULL; @@ -865,97 +1165,50 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) vb = res->variables; if (vb == NULL) { - if (res != NULL) - snmp_free_pdu (res); - res = NULL; - status = -1; break; } - /* Check if we left the subtree */ - if (snmp_oid_ncompare (data->instance.oid.oid, data->instance.oid.oid_len, - vb->name, vb->name_length, - data->instance.oid.oid_len) != 0) - { - if (res != NULL) - snmp_free_pdu (res); - res = NULL; - - break; - } - - /* Allocate a new `csnmp_list_instances_t', insert the instance name and - * add it to the list */ - il = (csnmp_list_instances_t *) malloc (sizeof (csnmp_list_instances_t)); - if (il == NULL) + /* Check if all values (and possibly the instance) have left their + * subtree */ + if (csnmp_check_res_left_subtree (host, data, res) != 0) { - if (res != NULL) - snmp_free_pdu (res); - res = NULL; - - status = -1; + status = 0; break; } - il->subid = vb->name[vb->name_length - 1]; - il->next = NULL; - /* Get instance name */ - if ((vb->type == ASN_OCTET_STR) || (vb->type == ASN_BIT_STR)) + /* if an instance-OID is configured.. */ + if (data->instance.oid.oid_len > 0) { - char *ptr; - size_t instance_len; - - instance_len = sizeof (il->instance) - 1; - if (instance_len > vb->val_len) - instance_len = vb->val_len; - - strncpy (il->instance, (char *) ((vb->type == ASN_OCTET_STR) - ? vb->val.string - : vb->val.bitstring), - instance_len); - il->instance[instance_len] = '\0'; - - for (ptr = il->instance; *ptr != '\0'; ptr++) + /* Allocate a new `csnmp_list_instances_t', insert the instance name and + * add it to the list */ + if (csnmp_instance_list_add (&instance_list, &instance_list_ptr, + res) != 0) { - if ((*ptr > 0) && (*ptr < 32)) - *ptr = ' '; - else if (*ptr == '/') - *ptr = '_'; + ERROR ("snmp plugin: csnmp_instance_list_add failed."); + status = -1; + break; } - DEBUG ("snmp plugin: il->instance = `%s';", il->instance); - } - else - { - value_t val = csnmp_value_list_to_value (vb, DS_TYPE_COUNTER); - snprintf (il->instance, sizeof (il->instance), - "%llu", val.counter); - } - il->instance[sizeof (il->instance) - 1] = '\0'; - DEBUG ("snmp plugin: data = `%s'; il->instance = `%s';", - data->name, il->instance); - - if (instance_list_ptr == NULL) - instance_list = il; - else - instance_list_ptr->next = il; - instance_list_ptr = il; - /* Copy OID to oid_list[0] */ - memcpy (oid_list[0].oid, vb->name, sizeof (oid) * vb->name_length); - oid_list[0].oid_len = vb->name_length; + /* Set vb on the last variable */ + for (vb = res->variables; + (vb != NULL) && (vb->next_variable != NULL); + vb = vb->next_variable) + /* do nothing */; + assert (vb != NULL); + + /* Copy OID to oid_list[data->values_len] */ + memcpy (oid_list[data->values_len].oid, vb->name, + sizeof (oid) * vb->name_length); + oid_list[data->values_len].oid_len = vb->name_length; + } - for (i = 0; i < data->values_len; i++) + for (vb = res->variables, i = 0; + (vb != NULL) && (i < data->values_len); + vb = vb->next_variable, i++) { csnmp_table_values_t *vt; - vb = vb->next_variable; - if (vb == NULL) - { - status = -1; - break; - } - /* Check if we left the subtree */ if (snmp_oid_ncompare (data->values[i].oid, data->values[i].oid_len, @@ -970,28 +1223,34 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) if ((value_table_ptr[i] != NULL) && (vb->name[vb->name_length - 1] <= value_table_ptr[i]->subid)) { - DEBUG ("snmp plugin: host = %s; data = %s; i = %i; SUBID is not increasing.", + DEBUG ("snmp plugin: host = %s; data = %s; i = %i; " + "SUBID is not increasing.", host->name, data->name, i); continue; } vt = (csnmp_table_values_t *) malloc (sizeof (csnmp_table_values_t)); - if (vt != NULL) + if (vt == NULL) { - vt->subid = vb->name[vb->name_length - 1]; - vt->value = csnmp_value_list_to_value (vb, ds->ds[i].type); - vt->next = NULL; - - if (value_table_ptr[i] == NULL) - value_table[i] = vt; - else - value_table_ptr[i]->next = vt; - value_table_ptr[i] = vt; + ERROR ("snmp plugin: malloc failed."); + status = -1; + break; } + vt->subid = vb->name[vb->name_length - 1]; + vt->value = csnmp_value_list_to_value (vb, ds->ds[i].type, + data->scale, data->shift); + vt->next = NULL; + + if (value_table_ptr[i] == NULL) + value_table[i] = vt; + else + value_table_ptr[i]->next = vt; + value_table_ptr[i] = vt; + /* Copy OID to oid_list[i + 1] */ - memcpy (oid_list[i + 1].oid, vb->name, sizeof (oid) * vb->name_length); - oid_list[i + 1].oid_len = vb->name_length; + memcpy (oid_list[i].oid, vb->name, sizeof (oid) * vb->name_length); + oid_list[i].oid_len = vb->name_length; } /* for (i = data->values_len) */ if (res != NULL) @@ -999,6 +1258,10 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) res = NULL; } /* while (status == 0) */ + if (res != NULL) + snmp_free_pdu (res); + res = NULL; + if (status == 0) csnmp_dispatch_table (host, data, instance_list, value_table); @@ -1074,11 +1337,10 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data) vl.values[i].gauge = NAN; } - strncpy (vl.host, host->name, sizeof (vl.host)); - vl.host[sizeof (vl.host) - 1] = '\0'; - strcpy (vl.plugin, "snmp"); - strncpy (vl.type_instance, data->instance.string, sizeof (vl.type_instance)); - vl.type_instance[sizeof (vl.type_instance) - 1] = '\0'; + sstrncpy (vl.host, host->name, sizeof (vl.host)); + sstrncpy (vl.plugin, "snmp", sizeof (vl.plugin)); + sstrncpy (vl.type, data->type, sizeof (vl.type)); + sstrncpy (vl.type_instance, data->instance.string, sizeof (vl.type_instance)); vl.interval = host->interval; @@ -1104,10 +1366,6 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data) ERROR ("snmp plugin: host %s: snmp_sess_synch_response failed: %s", host->name, (errstr == NULL) ? "Unknown problem" : errstr); - if (req != NULL) - snmp_free_pdu (req); - req = NULL; - if (res != NULL) snmp_free_pdu (res); res = NULL; @@ -1132,19 +1390,16 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data) for (i = 0; i < data->values_len; i++) if (snmp_oid_compare (data->values[i].oid, data->values[i].oid_len, vb->name, vb->name_length) == 0) - vl.values[i] = csnmp_value_list_to_value (vb, ds->ds[i].type); + vl.values[i] = csnmp_value_list_to_value (vb, ds->ds[i].type, + data->scale, data->shift); } /* for (res->variables) */ - if (req != NULL) - snmp_free_pdu (req); - req = NULL; - if (res != NULL) snmp_free_pdu (res); res = NULL; - DEBUG ("snmp plugin: -> plugin_dispatch_values (%s, &vl);", data->type); - plugin_dispatch_values (data->type, &vl); + DEBUG ("snmp plugin: -> plugin_dispatch_values (&vl);"); + plugin_dispatch_values (&vl); sfree (vl.values); return (0); @@ -1182,8 +1437,8 @@ static int csnmp_read_host (host_definition_t *host) if ((time_end - time_start) > host->interval) { WARNING ("snmp plugin: Host `%s' should be queried every %i seconds, " - "but reading all values takes %i seconds.", - host->name, host->interval, time_end - time_start); + "but reading all values takes %u seconds.", + host->name, host->interval, (unsigned int) (time_end - time_start)); } return (0);