X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsnmp.c;h=7d340d18c2398a8a26fb845d7b0e03352b53f903;hb=51a4e62d7d0e73d8d5822efaef1e3218b5ad0373;hp=54bcf67242170ea93c6cdc070a5a81a8196ed067;hpb=2652653c3db161442d28709d79c3f2d81ab571ee;p=collectd.git diff --git a/src/snmp.c b/src/snmp.c index 54bcf672..7d340d18 100644 --- a/src/snmp.c +++ b/src/snmp.c @@ -1,6 +1,6 @@ /** * collectd - src/snmp.c - * Copyright (C) 2007 Florian octo Forster + * Copyright (C) 2007-2012 Florian octo Forster * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -16,7 +16,7 @@ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: - * Florian octo Forster + * Florian octo Forster **/ #include "collectd.h" @@ -79,7 +79,7 @@ typedef struct host_definition_s host_definition_t; * gaps in tables. */ struct csnmp_list_instances_s { - oid subid; + oid_t suffix; char instance[DATA_MAX_NAME_LEN]; struct csnmp_list_instances_s *next; }; @@ -87,7 +87,7 @@ typedef struct csnmp_list_instances_s csnmp_list_instances_t; struct csnmp_table_values_s { - oid subid; + oid_t suffix; value_t value; struct csnmp_table_values_s *next; }; @@ -106,6 +106,54 @@ static int csnmp_read_host (user_data_t *ud); /* * Private functions */ +static void csnmp_oid_init (oid_t *dst, oid const *src, size_t n) +{ + assert (n <= STATIC_ARRAY_SIZE (dst->oid)); + memcpy (dst->oid, src, sizeof (*src) * n); + dst->oid_len = n; +} + +static int csnmp_oid_compare (oid_t const *left, oid_t const *right) +{ + return (snmp_oid_compare (left->oid, left->oid_len, + right->oid, right->oid_len)); +} + +static int csnmp_oid_suffix (oid_t *dst, oid_t const *src, + oid_t const *root) +{ + /* Make sure "src" is in "root"s subtree. */ + if (src->oid_len <= root->oid_len) + return (EINVAL); + if (snmp_oid_ncompare (root->oid, root->oid_len, + src->oid, src->oid_len, + /* n = */ root->oid_len) != 0) + return (EINVAL); + + memset (dst, 0, sizeof (*dst)); + dst->oid_len = src->oid_len - root->oid_len; + memcpy (dst->oid, &src->oid[root->oid_len], + dst->oid_len * sizeof (dst->oid[0])); + return (0); +} + +static int csnmp_oid_to_string (char *buffer, size_t buffer_size, + oid_t const *o) +{ + char oid_str[MAX_OID_LEN][16]; + char *oid_str_ptr[MAX_OID_LEN]; + size_t i; + + for (i = 0; i < o->oid_len; i++) + { + ssnprintf (oid_str[i], sizeof (oid_str[i]), "%lu", (unsigned long) o->oid[i]); + oid_str_ptr[i] = oid_str[i]; + } + + return (strjoin (buffer, buffer_size, + oid_str_ptr, o->oid_len, /* separator = */ ".")); +} + static void csnmp_host_close_session (host_definition_t *host) /* {{{ */ { if (host->sess_handle == NULL) @@ -127,7 +175,7 @@ static void csnmp_host_definition_destroy (void *arg) /* {{{ */ if (hd->name != NULL) { DEBUG ("snmp plugin: Destroying host definition for host `%s'.", - hd->name); + hd->name); } csnmp_host_close_session (hd); @@ -212,10 +260,10 @@ static int csnmp_config_add_data_instance (data_definition_t *dd, oconfig_item_t dd->instance.oid.oid_len = MAX_OID_LEN; if (!read_objid (ci->values[0].value.string, - dd->instance.oid.oid, &dd->instance.oid.oid_len)) + dd->instance.oid.oid, &dd->instance.oid.oid_len)) { ERROR ("snmp plugin: read_objid (%s) failed.", - ci->values[0].value.string); + ci->values[0].value.string); return (-1); } } @@ -223,7 +271,7 @@ static int csnmp_config_add_data_instance (data_definition_t *dd, oconfig_item_t { /* Instance is a simple string */ sstrncpy (dd->instance.string, ci->values[0].value.string, - sizeof (dd->instance.string)); + sizeof (dd->instance.string)); } return (0); @@ -241,7 +289,7 @@ static int csnmp_config_add_data_instance_prefix (data_definition_t *dd, if (!dd->is_table) { WARNING ("snmp plugin: data %s: InstancePrefix is ignored when `Table' " - "is set to `false'.", dd->name); + "is set to `false'.", dd->name); return (-1); } @@ -282,10 +330,10 @@ static int csnmp_config_add_data_values (data_definition_t *dd, oconfig_item_t * dd->values[i].oid_len = MAX_OID_LEN; if (NULL == snmp_parse_oid (ci->values[i].value.string, - dd->values[i].oid, &dd->values[i].oid_len)) + dd->values[i].oid, &dd->values[i].oid_len)) { ERROR ("snmp plugin: snmp_parse_oid (%s) failed.", - ci->values[i].value.string); + ci->values[i].value.string); free (dd->values); dd->values = NULL; dd->values_len = 0; @@ -301,7 +349,7 @@ static int csnmp_config_add_data_shift (data_definition_t *dd, oconfig_item_t *c if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) { - WARNING ("snmp plugin: The `Scale' config option needs exactly one number argument."); + WARNING ("snmp plugin: The `Shift' config option needs exactly one number argument."); return (-1); } @@ -523,17 +571,17 @@ static int csnmp_config_add_host_collect (host_definition_t *host, { for (data = data_head; data != NULL; data = data->next) if (strcasecmp (ci->values[i].value.string, data->name) == 0) - break; + break; if (data == NULL) { WARNING ("snmp plugin: No such data configured: `%s'", - ci->values[i].value.string); + ci->values[i].value.string); continue; } DEBUG ("snmp plugin: Collect: host = %s, data[%i] = %s;", - host->name, host->data_list_len, data->name); + host->name, host->data_list_len, data->name); host->data_list[host->data_list_len] = data; host->data_list_len++; @@ -696,19 +744,22 @@ static void csnmp_host_open_session (host_definition_t *host) snmp_error (&sess, NULL, NULL, &errstr); ERROR ("snmp plugin: host %s: snmp_sess_open failed: %s", - host->name, (errstr == NULL) ? "Unknown problem" : errstr); + host->name, (errstr == NULL) ? "Unknown problem" : errstr); sfree (errstr); } } /* void csnmp_host_open_session */ /* TODO: Check if negative values wrap around. Problem: negative temperatures. */ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, - double scale, double shift) + double scale, double shift, + const char *host_name, const char *data_name) { value_t ret; uint64_t tmp_unsigned = 0; int64_t tmp_signed = 0; - int defined = 1; + _Bool defined = 1; + /* Set to true when the original SNMP type appears to have been signed. */ + _Bool prefer_signed = 0; if ((vl->type == ASN_INTEGER) || (vl->type == ASN_UINTEGER) @@ -720,7 +771,12 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, { tmp_unsigned = (uint32_t) *vl->val.integer; tmp_signed = (int32_t) *vl->val.integer; - DEBUG ("snmp plugin: Parsed int32 value is %"PRIi64".", tmp_signed); + + if ((vl->type == ASN_INTEGER) + || (vl->type == ASN_GAUGE)) + prefer_signed = 1; + + DEBUG ("snmp plugin: Parsed int32 value is %"PRIu64".", tmp_unsigned); } else if (vl->type == ASN_COUNTER64) { @@ -740,16 +796,19 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, memset (oid_buffer, 0, sizeof (oid_buffer)); snprint_objid (oid_buffer, sizeof (oid_buffer) - 1, - vl->name, vl->name_length); + vl->name, vl->name_length); #ifdef ASN_NULL if (vl->type == ASN_NULL) INFO ("snmp plugin: OID \"%s\" is undefined (type ASN_NULL)", - oid_buffer); + oid_buffer); else #endif - WARNING ("snmp plugin: I don't know the ASN type \"%i\" (OID: %s)", - (int) vl->type, oid_buffer); + WARNING ("snmp plugin: I don't know the ASN type #%i " + "(OID: \"%s\", data block \"%s\", host block \"%s\")", + (int) vl->type, oid_buffer, + (data_name != NULL) ? data_name : "UNKNOWN", + (host_name != NULL) ? host_name : "UNKNOWN"); defined = 0; } @@ -765,7 +824,7 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, string_length = sizeof (string) - 1; if (vl->val_len < string_length) - string_length = vl->val_len; + 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 `memcpy' here and not `strcpy'. @@ -777,8 +836,8 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, status = parse_value (string, &ret, type); if (status != 0) { - ERROR ("snmp plugin: csnmp_value_list_to_value: Parsing string as %s failed: %s", - DS_TYPE_TO_STRING (type), string); + ERROR ("snmp plugin: csnmp_value_list_to_value: Parsing string as %s failed: %s", + DS_TYPE_TO_STRING (type), string); } } @@ -786,20 +845,20 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, { switch (type) { - case DS_TYPE_COUNTER: - case DS_TYPE_DERIVE: - case DS_TYPE_ABSOLUTE: - memset (&ret, 0, sizeof (ret)); - break; - - case DS_TYPE_GAUGE: - ret.gauge = NAN; - break; - - default: - ERROR ("snmp plugin: csnmp_value_list_to_value: Unknown " - "data source type: %i.", type); - ret.gauge = NAN; + case DS_TYPE_COUNTER: + case DS_TYPE_DERIVE: + case DS_TYPE_ABSOLUTE: + memset (&ret, 0, sizeof (ret)); + break; + + case DS_TYPE_GAUGE: + ret.gauge = NAN; + break; + + default: + ERROR ("snmp plugin: csnmp_value_list_to_value: Unknown " + "data source type: %i.", type); + ret.gauge = NAN; } } } /* if (vl->type == ASN_OCTET_STR) */ @@ -809,87 +868,34 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type, } else if (type == DS_TYPE_GAUGE) { - ret.gauge = NAN; - if (defined != 0) + if (!defined) + ret.gauge = NAN; + else if (prefer_signed) ret.gauge = (scale * tmp_signed) + shift; + else + ret.gauge = (scale * tmp_unsigned) + shift; } else if (type == DS_TYPE_DERIVE) - ret.derive = (derive_t) tmp_signed; + { + if (prefer_signed) + ret.derive = (derive_t) tmp_signed; + else + ret.derive = (derive_t) tmp_unsigned; + } else if (type == DS_TYPE_ABSOLUTE) + { ret.absolute = (absolute_t) tmp_unsigned; + } else { ERROR ("snmp plugin: csnmp_value_list_to_value: Unknown data source " - "type: %i.", type); + "type: %i.", type); ret.gauge = NAN; } 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_strvbcopy_hexstring (char *dst, /* {{{ */ const struct variable_list *vb, size_t dst_size) { @@ -905,7 +911,7 @@ static int csnmp_strvbcopy_hexstring (char *dst, /* {{{ */ int status; status = snprintf (buffer_ptr, buffer_free, - (i == 0) ? "%02x" : ":%02x", (unsigned int) vb->val.bitstring[i]); + (i == 0) ? "%02x" : ":%02x", (unsigned int) vb->val.bitstring[i]); if (status >= buffer_free) { @@ -958,10 +964,13 @@ static int csnmp_strvbcopy (char *dst, /* {{{ */ static int csnmp_instance_list_add (csnmp_list_instances_t **head, csnmp_list_instances_t **tail, - const struct snmp_pdu *res) + const struct snmp_pdu *res, + const host_definition_t *hd, const data_definition_t *dd) { csnmp_list_instances_t *il; struct variable_list *vb; + oid_t vb_name; + int status; /* Set vb on the last variable */ for (vb = res->variables; @@ -971,15 +980,24 @@ static int csnmp_instance_list_add (csnmp_list_instances_t **head, if (vb == NULL) return (-1); - il = (csnmp_list_instances_t *) malloc (sizeof (csnmp_list_instances_t)); + csnmp_oid_init (&vb_name, vb->name, vb->name_length); + + il = malloc (sizeof (*il)); if (il == NULL) { ERROR ("snmp plugin: malloc failed."); return (-1); } - il->subid = vb->name[vb->name_length - 1]; + memset (il, 0, sizeof (*il)); il->next = NULL; + status = csnmp_oid_suffix (&il->suffix, &vb_name, &dd->instance.oid); + if (status != 0) + { + sfree (il); + return (status); + } + /* Get instance name */ if ((vb->type == ASN_OCTET_STR) || (vb->type == ASN_BIT_STR)) { @@ -990,17 +1008,18 @@ static int csnmp_instance_list_add (csnmp_list_instances_t **head, for (ptr = il->instance; *ptr != '\0'; ptr++) { if ((*ptr > 0) && (*ptr < 32)) - *ptr = ' '; + *ptr = ' '; else if (*ptr == '/') - *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); + value_t val = csnmp_value_list_to_value (vb, DS_TYPE_COUNTER, + /* scale = */ 1.0, /* shift = */ 0.0, hd->name, dd->name); ssnprintf (il->instance, sizeof (il->instance), - "%llu", val.counter); + "%llu", val.counter); } /* TODO: Debugging output */ @@ -1025,8 +1044,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; + _Bool have_more; + oid_t current_suffix; ds = plugin_get_ds (data->type); if (!ds) @@ -1038,15 +1057,14 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat instance_list_ptr = instance_list; - value_table_ptr = (csnmp_table_values_t **) malloc (sizeof (csnmp_table_values_t *) - * data->values_len); + value_table_ptr = malloc (sizeof (*value_table_ptr) * data->values_len); if (value_table_ptr == NULL) return (-1); for (i = 0; i < data->values_len; i++) value_table_ptr[i] = value_table[i]; vl.values_len = ds->ds_num; - vl.values = (value_t *) malloc (sizeof (value_t) * vl.values_len); + vl.values = malloc (sizeof (*vl.values) * vl.values_len); if (vl.values == NULL) { ERROR ("snmp plugin: malloc failed."); @@ -1059,50 +1077,70 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat vl.interval = host->interval; - subid = 0; have_more = 1; - - while (have_more != 0) + memset (¤t_suffix, 0, sizeof (current_suffix)); + while (have_more) { + _Bool suffix_skipped = 0; + + /* Determine next suffix to handle. */ 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; + have_more = 0; + continue; } - else if (instance_list_ptr->subid > subid) + + memcpy (¤t_suffix, &instance_list_ptr->suffix, sizeof (current_suffix)); + } + else /* no instance configured */ + { + csnmp_table_values_t *ptr = value_table_ptr[0]; + if (ptr == NULL) { - subid = instance_list_ptr->subid; - continue; + have_more = 0; + continue; } - } /* if (instance_list != NULL) */ + memcpy (¤t_suffix, &ptr->suffix, sizeof (current_suffix)); + } + + /* Update all the value_table_ptr to point at the entry with the same + * trailing partial OID */ for (i = 0; i < data->values_len; i++) { while ((value_table_ptr[i] != NULL) - && (value_table_ptr[i]->subid < subid)) - value_table_ptr[i] = value_table_ptr[i]->next; + && (csnmp_oid_compare (&value_table_ptr[i]->suffix, ¤t_suffix) < 0)) + value_table_ptr[i] = value_table_ptr[i]->next; if (value_table_ptr[i] == NULL) { - have_more = 0; - break; + have_more = 0; + break; } - else if (value_table_ptr[i]->subid > subid) + else if (csnmp_oid_compare (&value_table_ptr[i]->suffix, ¤t_suffix) > 0) { - subid = value_table_ptr[i]->subid; - break; + /* This suffix is missing in the subtree. Indicate this with the + * "suffix_skipped" flag and try the next instance / suffix. */ + suffix_skipped = 1; + break; } } /* for (i = 0; i < columns; i++) */ - /* The subid has been increased - start scanning from the beginning - * again.. */ - if (i < data->values_len) + + if (!have_more) + break; + + /* Matching the values failed. Start from the beginning again. */ + if (suffix_skipped) + { + if (instance_list != NULL) + instance_list_ptr = instance_list_ptr->next; + else + value_table_ptr[0] = value_table_ptr[0]->next; + 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 @@ -1111,10 +1149,12 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat 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 (csnmp_oid_compare (&value_table_ptr[i-1]->suffix, + &value_table_ptr[i]->suffix) == 0); } assert ((instance_list_ptr == NULL) - || (instance_list_ptr->subid == value_table_ptr[0]->subid)); + || (csnmp_oid_compare (&instance_list_ptr->suffix, + &value_table_ptr[0]->suffix) == 0)); #endif sstrncpy (vl.type, data->type, sizeof (vl.type)); @@ -1123,15 +1163,15 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat char temp[DATA_MAX_NAME_LEN]; if (instance_list_ptr == NULL) - ssnprintf (temp, sizeof (temp), "%"PRIu32, (uint32_t) subid); + csnmp_oid_to_string (temp, sizeof (temp), ¤t_suffix); else - sstrncpy (temp, instance_list_ptr->instance, sizeof (temp)); + sstrncpy (temp, instance_list_ptr->instance, sizeof (temp)); if (data->instance_prefix == NULL) - sstrncpy (vl.type_instance, temp, sizeof (vl.type_instance)); + sstrncpy (vl.type_instance, temp, sizeof (vl.type_instance)); else - ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s%s", - data->instance_prefix, temp); + ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s%s", + data->instance_prefix, temp); } for (i = 0; i < data->values_len; i++) @@ -1140,8 +1180,11 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat /* If we get here `vl.type_instance' and all `vl.values' have been set */ plugin_dispatch_values (&vl); - subid++; - } /* while (have_more != 0) */ + if (instance_list != NULL) + instance_list_ptr = instance_list_ptr->next; + else + value_table_ptr[0] = value_table_ptr[0]->next; + } /* while (have_more) */ sfree (vl.values); sfree (value_table_ptr); @@ -1156,19 +1199,26 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) struct variable_list *vb; const data_set_t *ds; - oid_t *oid_list; - uint32_t oid_list_len; + + uint32_t oid_list_len = (uint32_t) (data->values_len + 1); + /* Holds the last OID returned by the device. We use this in the GETNEXT + * request to proceed. */ + oid_t oid_list[oid_list_len]; + /* Set to false when an OID has left its subtree so we don't re-request it + * again. */ + _Bool oid_list_todo[oid_list_len]; int status; int i; + uint32_t j; - /* `value_table' and `value_table_ptr' implement a linked list for each - * value. `instance_list' and `instance_list_ptr' implement a linked list of + /* `value_list_head' and `value_list_tail' implement a linked list for each + * value. `instance_list_head' and `instance_list_tail' implement a linked list of * instance names. This is used to jump gaps in the table. */ - csnmp_list_instances_t *instance_list; - csnmp_list_instances_t *instance_list_ptr; - csnmp_table_values_t **value_table; - csnmp_table_values_t **value_table_ptr; + csnmp_list_instances_t *instance_list_head; + csnmp_list_instances_t *instance_list_tail; + csnmp_table_values_t **value_list_head; + csnmp_table_values_t **value_list_tail; DEBUG ("snmp plugin: csnmp_read_table (host = %s, data = %s)", host->name, data->name); @@ -1189,42 +1239,41 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) if (ds->ds_num != data->values_len) { ERROR ("snmp plugin: DataSet `%s' requires %i values, but config talks about %i", - data->type, ds->ds_num, data->values_len); + data->type, ds->ds_num, data->values_len); return (-1); } /* We need a copy of all the OIDs, because GETNEXT will destroy them. */ - 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->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 + else /* no InstanceFrom option specified. */ 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) + for (j = 0; j < oid_list_len; j++) + oid_list_todo[j] = 1; + + /* We're going to construct n linked lists, one for each "value". + * value_list_head will contain pointers to the heads of these linked lists, + * value_list_tail will contain pointers to the tail of the lists. */ + value_list_head = calloc (data->values_len, sizeof (*value_list_head)); + value_list_tail = calloc (data->values_len, sizeof (*value_list_tail)); + if ((value_list_head == NULL) || (value_list_tail == NULL)) { - ERROR ("snmp plugin: csnmp_read_table: malloc failed."); - sfree (oid_list); + ERROR ("snmp plugin: csnmp_read_table: calloc failed."); + sfree (value_list_head); + sfree (value_list_tail); return (-1); } - memset (value_table, '\0', sizeof (csnmp_table_values_t *) * 2 * data->values_len); - value_table_ptr = value_table + data->values_len; - - instance_list = NULL; - instance_list_ptr = NULL; + + instance_list_head = NULL; + instance_list_tail = NULL; status = 0; while (status == 0) { + int oid_list_todo_num; + req = snmp_pdu_create (SNMP_MSG_GETNEXT); if (req == NULL) { @@ -1233,12 +1282,26 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) break; } - for (i = 0; (uint32_t) i < oid_list_len; i++) - snmp_add_null_var (req, oid_list[i].oid, oid_list[i].oid_len); + oid_list_todo_num = 0; + for (j = 0; j < oid_list_len; j++) + { + /* Do not rerequest already finished OIDs */ + if (!oid_list_todo[j]) + continue; + oid_list_todo_num++; + snmp_add_null_var (req, oid_list[j].oid, oid_list[j].oid_len); + } + + if (oid_list_todo_num == 0) + { + /* The request is still empty - so we are finished */ + DEBUG ("snmp plugin: all variables have left their subtree"); + status = 0; + break; + } res = NULL; status = snmp_sess_synch_response (host->sess_handle, req, &res); - if ((status != STAT_SUCCESS) || (res == NULL)) { char *errstr = NULL; @@ -1246,24 +1309,27 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) snmp_sess_error (host->sess_handle, NULL, NULL, &errstr); c_complain (LOG_ERR, &host->complaint, - "snmp plugin: host %s: snmp_sess_synch_response failed: %s", - host->name, (errstr == NULL) ? "Unknown problem" : errstr); + "snmp plugin: host %s: snmp_sess_synch_response failed: %s", + host->name, (errstr == NULL) ? "Unknown problem" : errstr); if (res != NULL) - snmp_free_pdu (res); + snmp_free_pdu (res); res = NULL; + /* snmp_synch_response already freed our PDU */ + req = NULL; sfree (errstr); csnmp_host_close_session (host); status = -1; break; } + status = 0; assert (res != NULL); c_release (LOG_INFO, &host->complaint, - "snmp plugin: host %s: snmp_sess_synch_response successful.", - host->name); + "snmp plugin: host %s: snmp_sess_synch_response successful.", + host->name); vb = res->variables; if (vb == NULL) @@ -1272,89 +1338,97 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) break; } - /* Check if all values (and possibly the instance) have left their - * subtree */ - if (csnmp_check_res_left_subtree (host, data, res) != 0) + for (vb = res->variables, i = 0; (vb != NULL); vb = vb->next_variable, i++) { - status = 0; - break; - } + /* Calculate value index from todo list */ + while (!oid_list_todo[i] && (i < oid_list_len)) + i++; - /* if an instance-OID is configured.. */ - if (data->instance.oid.oid_len > 0) - { - /* 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) + /* An instance is configured and the res variable we process is the + * instance value (last index) */ + if ((data->instance.oid.oid_len > 0) && (i == data->values_len)) { - ERROR ("snmp plugin: csnmp_instance_list_add failed."); - status = -1; - break; + if ((vb->type == SNMP_ENDOFMIBVIEW) + || (snmp_oid_ncompare (data->instance.oid.oid, + data->instance.oid.oid_len, + vb->name, vb->name_length, + data->instance.oid.oid_len) != 0)) + { + DEBUG ("snmp plugin: host = %s; data = %s; Instance left its subtree.", + host->name, data->name); + oid_list_todo[i] = 0; + continue; + } + + /* Allocate a new `csnmp_list_instances_t', insert the instance name and + * add it to the list */ + if (csnmp_instance_list_add (&instance_list_head, &instance_list_tail, + res, host, data) != 0) + { + ERROR ("snmp plugin: csnmp_instance_list_add failed."); + status = -1; + break; + } } - - /* 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 (vb = res->variables, i = 0; - (vb != NULL) && (i < data->values_len); - vb = vb->next_variable, i++) - { - csnmp_table_values_t *vt; - - /* Check if we left the subtree */ - if (snmp_oid_ncompare (data->values[i].oid, - data->values[i].oid_len, - vb->name, vb->name_length, - data->values[i].oid_len) != 0) - { - DEBUG ("snmp plugin: host = %s; data = %s; Value %i left its subtree.", - host->name, data->name, i); - continue; - } - - 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.", - host->name, data->name, i); - continue; - } - - vt = (csnmp_table_values_t *) malloc (sizeof (csnmp_table_values_t)); - if (vt == NULL) + else /* The variable we are processing is a normal value */ { - ERROR ("snmp plugin: malloc failed."); - status = -1; - break; + csnmp_table_values_t *vt; + oid_t vb_name; + oid_t suffix; + int ret; + + csnmp_oid_init (&vb_name, vb->name, vb->name_length); + + /* Calculate the current suffix. This is later used to check that the + * suffix is increasing. This also checks if we left the subtree */ + ret = csnmp_oid_suffix (&suffix, &vb_name, data->values + i); + if (ret != 0) + { + DEBUG ("snmp plugin: host = %s; data = %s; i = %i; " + "Value probably left its subtree.", + host->name, data->name, i); + oid_list_todo[i] = 0; + continue; + } + + /* Make sure the OIDs returned by the agent are increasing. Otherwise our + * table matching algorithm will get confused. */ + if ((value_list_tail[i] != NULL) + && (csnmp_oid_compare (&suffix, &value_list_tail[i]->suffix) <= 0)) + { + DEBUG ("snmp plugin: host = %s; data = %s; i = %i; " + "Suffix is not increasing.", + host->name, data->name, i); + oid_list_todo[i] = 0; + continue; + } + + vt = malloc (sizeof (*vt)); + if (vt == NULL) + { + ERROR ("snmp plugin: malloc failed."); + status = -1; + break; + } + memset (vt, 0, sizeof (*vt)); + + vt->value = csnmp_value_list_to_value (vb, ds->ds[i].type, + data->scale, data->shift, host->name, data->name); + memcpy (&vt->suffix, &suffix, sizeof (vt->suffix)); + vt->next = NULL; + + if (value_list_tail[i] == NULL) + value_list_head[i] = vt; + else + value_list_tail[i]->next = vt; + value_list_tail[i] = vt; } - 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] */ + /* Copy OID to oid_list[i] */ 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) */ + + } /* for (vb = res->variables ...) */ if (res != NULL) snmp_free_pdu (res); @@ -1365,30 +1439,33 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data) snmp_free_pdu (res); res = NULL; + if (req != NULL) + snmp_free_pdu (req); + req = NULL; + if (status == 0) - csnmp_dispatch_table (host, data, instance_list, value_table); + csnmp_dispatch_table (host, data, instance_list_head, value_list_head); /* Free all allocated variables here */ - while (instance_list != NULL) + while (instance_list_head != NULL) { - instance_list_ptr = instance_list->next; - sfree (instance_list); - instance_list = instance_list_ptr; + csnmp_list_instances_t *next = instance_list_head->next; + sfree (instance_list_head); + instance_list_head = next; } for (i = 0; i < data->values_len; i++) { - csnmp_table_values_t *tmp; - while (value_table[i] != NULL) + while (value_list_head[i] != NULL) { - tmp = value_table[i]->next; - sfree (value_table[i]); - value_table[i] = tmp; + csnmp_table_values_t *next = value_list_head[i]->next; + sfree (value_list_head[i]); + value_list_head[i] = next; } } - sfree (value_table); - sfree (oid_list); + sfree (value_list_head); + sfree (value_list_tail); return (0); } /* int csnmp_read_table */ @@ -1424,7 +1501,7 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data) if (ds->ds_num != data->values_len) { ERROR ("snmp plugin: DataSet `%s' requires %i values, but config talks about %i", - data->type, ds->ds_num, data->values_len); + data->type, ds->ds_num, data->values_len); return (-1); } @@ -1467,7 +1544,7 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data) snmp_sess_error (host->sess_handle, NULL, NULL, &errstr); ERROR ("snmp plugin: host %s: snmp_sess_synch_response failed: %s", - host->name, (errstr == NULL) ? "Unknown problem" : errstr); + host->name, (errstr == NULL) ? "Unknown problem" : errstr); if (res != NULL) snmp_free_pdu (res); @@ -1485,15 +1562,15 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data) #if COLLECT_DEBUG char buffer[1024]; snprint_variable (buffer, sizeof (buffer), - vb->name, vb->name_length, vb); + vb->name, vb->name_length, vb); DEBUG ("snmp plugin: Got this variable: %s", buffer); #endif /* COLLECT_DEBUG */ 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, - data->scale, data->shift); + vb->name, vb->name_length) == 0) + vl.values[i] = csnmp_value_list_to_value (vb, ds->ds[i].type, + data->scale, data->shift, host->name, data->name); } /* for (res->variables) */ if (res != NULL) @@ -1519,7 +1596,7 @@ static int csnmp_read_host (user_data_t *ud) host = ud->data; if (host->interval == 0) - host->interval = interval_g; + host->interval = plugin_get_interval (); time_start = cdtime (); @@ -1547,10 +1624,10 @@ static int csnmp_read_host (user_data_t *ud) if ((time_end - time_start) > host->interval) { WARNING ("snmp plugin: Host `%s' should be queried every %.3f " - "seconds, but reading all values takes %.3f seconds.", - host->name, - CDTIME_T_TO_DOUBLE (host->interval), - CDTIME_T_TO_DOUBLE (time_end - time_start)); + "seconds, but reading all values takes %.3f seconds.", + host->name, + CDTIME_T_TO_DOUBLE (host->interval), + CDTIME_T_TO_DOUBLE (time_end - time_start)); } if (success == 0)