![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/snmp.c b/src/snmp.c
index 352075f26ded8ef75802d020c069de9d53836c0a..e265ae07ad9e514b48ea6e2c07966453ff271b3f 100644 (file)
--- a/src/snmp.c
+++ b/src/snmp.c
/**
* 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
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* Authors:
- * Florian octo Forster <octo at verplant.org>
+ * Florian octo Forster <octo at collectd.org>
**/
#include "collectd.h"
void *sess_handle;
c_complain_t complaint;
uint32_t interval;
- time_t next_update;
data_definition_t **data_list;
int data_list_len;
- enum /******************************************************/
- { /* This host.. */
- STATE_IDLE, /* - just sits there until `next_update < interval_g' */
- STATE_WAIT, /* - waits to be queried. */
- STATE_BUSY /* - is currently being queried. */
- } state; /******************************************************/
- struct host_definition_s *next;
};
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;
};
struct csnmp_table_values_s
{
- oid subid;
+ oid_t suffix;
value_t value;
struct csnmp_table_values_s *next;
};
/*
* Private variables
*/
-static int do_shutdown = 0;
-
-pthread_t *threads = NULL;
-int threads_num = 0;
-
static data_definition_t *data_head = NULL;
-static host_definition_t *host_head = NULL;
-static pthread_mutex_t host_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t host_cond = PTHREAD_COND_INITIALIZER;
+/*
+ * Prototypes
+ */
+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_LEN (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)
+ return;
+
+ snmp_sess_close (host->sess_handle);
+ host->sess_handle = NULL;
+} /* }}} void csnmp_host_close_session */
+
+static void csnmp_host_definition_destroy (void *arg) /* {{{ */
+{
+ host_definition_t *hd;
+
+ hd = arg;
+
+ if (hd == NULL)
+ return;
+
+ if (hd->name != NULL)
+ {
+ DEBUG ("snmp plugin: Destroying host definition for host `%s'.",
+ hd->name);
+ }
+
+ csnmp_host_close_session (hd);
+
+ sfree (hd->name);
+ sfree (hd->address);
+ sfree (hd->community);
+ sfree (hd->data_list);
+
+ sfree (hd);
+} /* }}} void csnmp_host_definition_destroy */
+
/* Many functions to handle the configuration. {{{ */
/* First there are many functions which do configuration stuff. It's a big
* bloated and messy, I'm afraid. */
@@ -191,10 +261,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);
}
}
@@ -202,7 +272,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);
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);
}
@@ -261,10 +331,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;
@@ -280,7 +350,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);
}
{
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++;
int status = 0;
int i;
+ /* Registration stuff. */
+ char cb_name[DATA_MAX_NAME_LEN];
+ user_data_t cb_data;
+ struct timespec cb_interval;
+
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("snmp plugin: `Host' needs exactly one string argument.");
hd->sess_handle = NULL;
hd->interval = 0;
- hd->next_update = 0;
- hd->state = STATE_IDLE;
for (i = 0; i < ci->children_num; i++)
{
if (status != 0)
{
- sfree (hd->name);
- sfree (hd);
+ csnmp_host_definition_destroy (hd);
return (-1);
}
DEBUG ("snmp plugin: hd = { name = %s, address = %s, community = %s, version = %i }",
hd->name, hd->address, hd->community, hd->version);
- if (host_head == NULL)
- host_head = hd;
- else
+ ssnprintf (cb_name, sizeof (cb_name), "snmp-%s", hd->name);
+
+ memset (&cb_data, 0, sizeof (cb_data));
+ cb_data.data = hd;
+ cb_data.free_func = csnmp_host_definition_destroy;
+
+ memset (&cb_interval, 0, sizeof (cb_interval));
+ if (hd->interval != 0)
+ cb_interval.tv_sec = (time_t) hd->interval;
+
+ status = plugin_register_complex_read (/* group = */ NULL, cb_name,
+ csnmp_read_host, /* interval = */ &cb_interval,
+ /* user_data = */ &cb_data);
+ if (status != 0)
{
- host_definition_t *last;
- last = host_head;
- while (last->next != NULL)
- last = last->next;
- last->next = hd;
+ ERROR ("snmp plugin: Registering complex read function failed.");
+ csnmp_host_definition_destroy (hd);
+ return (-1);
}
return (0);
/* }}} End of the config stuff. Now the interesting part begins */
-static void csnmp_host_close_session (host_definition_t *host)
-{
- if (host->sess_handle == NULL)
- return;
-
- snmp_sess_close (host->sess_handle);
- host->sess_handle = NULL;
-} /* void csnmp_host_close_session */
-
static void csnmp_host_open_session (host_definition_t *host)
{
struct snmp_session sess;
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 */
double scale, double shift)
{
value_t ret;
- uint64_t temp = 0;
- int defined = 1;
+ uint64_t tmp_unsigned = 0;
+ int64_t tmp_signed = 0;
+ _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)
#endif
|| (vl->type == ASN_GAUGE))
{
- temp = (uint32_t) *vl->val.integer;
- DEBUG ("snmp plugin: Parsed int32 value is %"PRIu64".", temp);
+ tmp_unsigned = (uint32_t) *vl->val.integer;
+ tmp_signed = (int32_t) *vl->val.integer;
+
+ 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)
{
- temp = (uint32_t) vl->val.counter64->high;
- temp = temp << 32;
- temp += (uint32_t) vl->val.counter64->low;
- DEBUG ("snmp plugin: Parsed int64 value is %"PRIu64".", temp);
+ tmp_unsigned = (uint32_t) vl->val.counter64->high;
+ tmp_unsigned = tmp_unsigned << 32;
+ tmp_unsigned += (uint32_t) vl->val.counter64->low;
+ tmp_signed = (int64_t) tmp_unsigned;
+ DEBUG ("snmp plugin: Parsed int64 value is %"PRIu64".", tmp_unsigned);
}
else if (vl->type == ASN_OCTET_STR)
{
}
else
{
- WARNING ("snmp plugin: I don't know the ASN type `%i'", (int) vl->type);
+ char oid_buffer[1024];
+
+ memset (oid_buffer, 0, sizeof (oid_buffer));
+ snprint_objid (oid_buffer, sizeof (oid_buffer) - 1,
+ 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);
+ else
+#endif
+ WARNING ("snmp plugin: I don't know the ASN type \"%i\" (OID: %s)",
+ (int) vl->type, oid_buffer);
+
defined = 0;
}
if (vl->type == ASN_OCTET_STR)
{
- char *endptr;
+ int status = -1;
- endptr = NULL;
if (vl->val.string != NULL)
{
char string[64];
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 `membpy' here and not `strcpy'.
+ * terminated. That is why we're using `memcpy' 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)
+ status = parse_value (string, &ret, type);
+ if (status != 0)
{
- ret.gauge = (gauge_t) strtod (string, &endptr);
- DEBUG ("snmp plugin: csnmp_value_list_to_value: String to gauge: %s -> %g",
- string, (double) ret.gauge);
+ ERROR ("snmp plugin: csnmp_value_list_to_value: Parsing string as %s failed: %s",
+ DS_TYPE_TO_STRING (type), string);
}
}
- /* Check if an error occurred */
- if ((vl->val.string == NULL) || (endptr == (char *) vl->val.string))
+ if (status != 0)
{
- if (type == DS_TYPE_COUNTER)
- ret.counter = 0;
- else if (type == DS_TYPE_GAUGE)
- ret.gauge = NAN;
+ 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;
+ }
}
- }
+ } /* if (vl->type == ASN_OCTET_STR) */
else if (type == DS_TYPE_COUNTER)
{
- ret.counter = temp;
+ ret.counter = tmp_unsigned;
}
else if (type == DS_TYPE_GAUGE)
{
+ 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)
+ {
+ 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);
ret.gauge = NAN;
- if (defined != 0)
- ret.gauge = (scale * temp) + shift;
}
return (ret);
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)
+
+ if ((vb->type == SNMP_ENDOFMIBVIEW)
+ || (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++;
}
if (i < data->values_len)
{
ERROR ("snmp plugin: host %s: Expected %i variables, but got only %i",
- host->name, data->values_len, i);
+ host->name, data->values_len, i);
return (-1);
}
if (vb == NULL)
{
ERROR ("snmp plugin: host %s: Expected one more variable for "
- "the instance..", host->name);
+ "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)
+ data->instance.oid.oid_len,
+ vb->name, vb->name_length,
+ data->instance.oid.oid_len) != 0)
num_left_subtree++;
}
return (0);
} /* int csnmp_check_res_left_subtree */
+static int csnmp_strvbcopy_hexstring (char *dst, /* {{{ */
+ const struct variable_list *vb, size_t dst_size)
+{
+ char *buffer_ptr;
+ size_t buffer_free;
+ size_t i;
+
+ buffer_ptr = dst;
+ buffer_free = dst_size;
+
+ for (i = 0; i < vb->val_len; i++)
+ {
+ int status;
+
+ status = snprintf (buffer_ptr, buffer_free,
+ (i == 0) ? "%02x" : ":%02x", (unsigned int) vb->val.bitstring[i]);
+
+ if (status >= buffer_free)
+ {
+ buffer_ptr += (buffer_free - 1);
+ *buffer_ptr = 0;
+ return (dst_size + (buffer_free - status));
+ }
+ else /* if (status < buffer_free) */
+ {
+ buffer_ptr += status;
+ buffer_free -= status;
+ }
+ }
+
+ return ((int) (dst_size - buffer_free));
+} /* }}} int csnmp_strvbcopy_hexstring */
+
+static int csnmp_strvbcopy (char *dst, /* {{{ */
+ const struct variable_list *vb, size_t dst_size)
+{
+ char *src;
+ size_t num_chars;
+ size_t i;
+
+ if (vb->type == ASN_OCTET_STR)
+ src = (char *) vb->val.string;
+ else if (vb->type == ASN_BIT_STR)
+ src = (char *) vb->val.bitstring;
+ else
+ {
+ dst[0] = 0;
+ return (EINVAL);
+ }
+
+ num_chars = dst_size - 1;
+ if (num_chars > vb->val_len)
+ num_chars = vb->val_len;
+
+ for (i = 0; i < num_chars; i++)
+ {
+ /* Check for control characters. */
+ if ((unsigned char)src[i] < 32)
+ return (csnmp_strvbcopy_hexstring (dst, vb, dst_size));
+ dst[i] = src[i];
+ }
+ dst[num_chars] = 0;
+
+ return ((int) vb->val_len);
+} /* }}} int csnmp_strvbcopy */
+
static int csnmp_instance_list_add (csnmp_list_instances_t **head,
csnmp_list_instances_t **tail,
- const struct snmp_pdu *res)
+ struct snmp_pdu const *res,
+ oid_t const *root)
{
csnmp_list_instances_t *il;
struct variable_list *vb;
+ oid_t vb_name;
/* Set vb on the last variable */
for (vb = res->variables;
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];
+ csnmp_oid_suffix (&il->suffix, &vb_name, root);
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);
+ csnmp_strvbcopy (il->instance, vb, sizeof (il->instance));
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);
}
{
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);
+ "%llu", val.counter);
}
/* TODO: Debugging output */
@@ -931,8 +1115,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)
@@ -965,49 +1149,61 @@ 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;
-
+ 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];
+ ptr = ptr->next;
+ 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)
+
+ /* Matching the values failed. Start from the beginning again. */
+ if (!have_more || suffix_skipped)
continue;
/* if we reach this line, all value_table_ptr[i] are non-NULL and are set
@@ -1017,10 +1213,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));
@@ -1029,15 +1227,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), "%u", (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++)
@@ -1045,9 +1243,7 @@ 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) */
+ } /* while (have_more) */
sfree (vl.values);
sfree (value_table_ptr);
@@ -1068,13 +1264,13 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data)
int status;
int i;
- /* `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);
@@ -1095,7 +1291,7 @@ 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);
}
@@ -1113,20 +1309,22 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data)
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)
+ /* 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.");
+ ERROR ("snmp plugin: csnmp_read_table: calloc failed.");
sfree (oid_list);
+ 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)
@@ -1152,11 +1350,11 @@ 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;
sfree (errstr);
@@ -1168,8 +1366,8 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data)
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)
@@ -1186,76 +1384,89 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data)
break;
}
- /* if an instance-OID is configured.. */
+ /* Copy the OID of the value used as instance to oid_list, if an instance
+ * 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)
+ if (csnmp_instance_list_add (&instance_list_head, &instance_list_tail,
+ res, &data->instance.oid) != 0)
{
- ERROR ("snmp plugin: csnmp_instance_list_add failed.");
- status = -1;
- break;
+ ERROR ("snmp plugin: csnmp_instance_list_add failed.");
+ status = -1;
+ break;
}
- /* Set vb on the last variable */
+ /* The instance OID is added to the list of OIDs to GET from the
+ * snmp agent last, so set vb on the last variable returned and copy
+ * that OID. */
for (vb = res->variables;
- (vb != NULL) && (vb->next_variable != NULL);
- vb = vb->next_variable)
- /* do nothing */;
+ (vb != NULL) && (vb->next_variable != NULL);
+ vb = vb->next_variable)
+ /* do nothing */;
assert (vb != NULL);
- /* Copy OID to oid_list[data->values_len] */
+ /* Copy the OID of the instance value to oid_list[data->values_len].
+ * "oid_list" is used for the next GETNEXT request. */
memcpy (oid_list[data->values_len].oid, vb->name,
- sizeof (oid) * vb->name_length);
+ sizeof (oid) * vb->name_length);
oid_list[data->values_len].oid_len = vb->name_length;
}
+ /* Iterate over all the (non-instance) values returned by the agent. The
+ * (i < value_len) check will make sure we're not handling the instance OID
+ * twice. */
for (vb = res->variables, i = 0;
- (vb != NULL) && (i < data->values_len);
- vb = vb->next_variable, i++)
+ (vb != NULL) && (i < data->values_len);
+ vb = vb->next_variable, i++)
{
csnmp_table_values_t *vt;
+ oid_t vb_name;
+
+ csnmp_oid_init (&vb_name, vb->name, vb->name_length);
/* 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)
+ 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;
+ 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))
+ /* 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 (&vb_name, &value_list_tail[i]->suffix) <= 0))
{
- DEBUG ("snmp plugin: host = %s; data = %s; i = %i; "
- "SUBID is not increasing.",
- host->name, data->name, i);
- continue;
+ 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));
+ vt = malloc (sizeof (*vt));
if (vt == NULL)
{
- ERROR ("snmp plugin: malloc failed.");
- status = -1;
- break;
+ ERROR ("snmp plugin: malloc failed.");
+ status = -1;
+ break;
}
+ memset (vt, 0, sizeof (*vt));
- vt->subid = vb->name[vb->name_length - 1];
+ csnmp_oid_suffix (&vt->suffix, &vb_name, data->values + i);
vt->value = csnmp_value_list_to_value (vb, ds->ds[i].type,
- data->scale, data->shift);
+ data->scale, data->shift);
vt->next = NULL;
- if (value_table_ptr[i] == NULL)
- value_table[i] = vt;
+ if (value_list_tail[i] == NULL)
+ value_list_head[i] = vt;
else
- value_table_ptr[i]->next = vt;
- value_table_ptr[i] = vt;
+ value_list_tail[i]->next = vt;
+ value_list_tail[i] = vt;
/* Copy OID to oid_list[i + 1] */
memcpy (oid_list[i].oid, vb->name, sizeof (oid) * vb->name_length);
@@ -1272,28 +1483,28 @@ static int csnmp_read_table (host_definition_t *host, data_definition_t *data)
res = 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 (value_list_head);
+ sfree (value_list_tail);
sfree (oid_list);
return (0);
@@ -1330,7 +1541,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);
}
@@ -1373,7 +1584,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);
@@ -1391,15 +1602,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);
} /* for (res->variables) */
if (res != NULL)
@@ -1413,11 +1624,19 @@ static int csnmp_read_value (host_definition_t *host, data_definition_t *data)
return (0);
} /* int csnmp_read_value */
-static int csnmp_read_host (host_definition_t *host)
+static int csnmp_read_host (user_data_t *ud)
{
- int i;
+ host_definition_t *host;
time_t time_start;
time_t time_end;
+ int status;
+ int success;
+ int i;
+
+ host = ud->data;
+
+ if (host->interval == 0)
+ host->interval = interval_g;
time_start = time (NULL);
DEBUG ("snmp plugin: csnmp_read_host (%s) started at %u;", host->name,
if (host->sess_handle == NULL)
return (-1);
+ success = 0;
for (i = 0; i < host->data_list_len; i++)
{
data_definition_t *data = host->data_list[i];
if (data->is_table)
- csnmp_read_table (host, data);
+ status = csnmp_read_table (host, data);
else
- csnmp_read_value (host, data);
+ status = csnmp_read_value (host, data);
+
+ if (status == 0)
+ success++;
}
time_end = time (NULL);
(unsigned int) time_end);
if ((uint32_t) (time_end - time_start) > host->interval)
{
- WARNING ("snmp plugin: Host `%s' should be queried every %i seconds, "
- "but reading all values takes %u seconds.",
- host->name, host->interval, (unsigned int) (time_end - time_start));
+ WARNING ("snmp plugin: Host `%s' should be queried every %"PRIu32
+ " seconds, but reading all values takes %u seconds.",
+ host->name, host->interval, (unsigned int) (time_end - time_start));
}
+ if (success == 0)
+ return (-1);
+
return (0);
} /* int csnmp_read_host */
-static void *csnmp_read_thread (void __attribute__((unused)) *data)
-{
- host_definition_t *host;
-
- pthread_mutex_lock (&host_lock);
- while (do_shutdown == 0)
- {
- pthread_cond_wait (&host_cond, &host_lock);
-
- for (host = host_head; host != NULL; host = host->next)
- {
- if (do_shutdown != 0)
- break;
- if (host->state != STATE_WAIT)
- continue;
-
- host->state = STATE_BUSY;
- pthread_mutex_unlock (&host_lock);
- csnmp_read_host (host);
- pthread_mutex_lock (&host_lock);
- host->state = STATE_IDLE;
- } /* for (host) */
- } /* while (do_shutdown == 0) */
- pthread_mutex_unlock (&host_lock);
-
- pthread_exit ((void *) 0);
- return ((void *) 0);
-} /* void *csnmp_read_thread */
-
static int csnmp_init (void)
{
- host_definition_t *host;
- int i;
-
- if (host_head == NULL)
- {
- NOTICE ("snmp plugin: No host has been defined.");
- return (-1);
- }
-
call_snmp_init_once ();
- threads_num = 0;
- for (host = host_head; host != NULL; host = host->next)
- {
- threads_num++;
- /* We need to initialize `interval' here, because `interval_g' isn't
- * initialized during `configure'. */
- host->next_update = time (NULL);
- if (host->interval == 0)
- {
- host->interval = interval_g;
- }
- else if (host->interval < (uint32_t) interval_g)
- {
- host->interval = interval_g;
- WARNING ("snmp plugin: Data for host `%s' will be collected every %i seconds.",
- host->name, host->interval);
- }
-
- csnmp_host_open_session (host);
- } /* for (host) */
-
- /* Now start the reading threads */
- if (threads_num > 3)
- {
- threads_num = 3 + ((threads_num - 3) / 10);
- if (threads_num > 10)
- threads_num = 10;
- }
-
- threads = (pthread_t *) malloc (threads_num * sizeof (pthread_t));
- if (threads == NULL)
- {
- ERROR ("snmp plugin: malloc failed.");
- return (-1);
- }
- memset (threads, '\0', threads_num * sizeof (pthread_t));
-
- for (i = 0; i < threads_num; i++)
- pthread_create (threads + i, NULL, csnmp_read_thread, (void *) 0);
-
return (0);
} /* int csnmp_init */
-static int csnmp_read (void)
-{
- host_definition_t *host;
- time_t now;
-
- if (host_head == NULL)
- {
- INFO ("snmp plugin: No hosts configured.");
- return (-1);
- }
-
- now = time (NULL);
-
- pthread_mutex_lock (&host_lock);
- for (host = host_head; host != NULL; host = host->next)
- {
- if (host->state != STATE_IDLE)
- continue;
-
- /* Skip this host if the next or a later iteration will be sufficient. */
- if (host->next_update >= (now + interval_g))
- continue;
-
- host->state = STATE_WAIT;
- host->next_update = now + host->interval;
- } /* for (host) */
-
- pthread_cond_broadcast (&host_cond);
- pthread_mutex_unlock (&host_lock);
-
- return (0);
-} /* int csnmp_read */
-
static int csnmp_shutdown (void)
{
- host_definition_t *host_this;
- host_definition_t *host_next;
-
data_definition_t *data_this;
data_definition_t *data_next;
- int i;
-
- pthread_mutex_lock (&host_lock);
- do_shutdown = 1;
- pthread_cond_broadcast (&host_cond);
- pthread_mutex_unlock (&host_lock);
-
- for (i = 0; i < threads_num; i++)
- pthread_join (threads[i], NULL);
-
- /* Now that all the threads have exited, let's free all the global variables.
- * This isn't really neccessary, I guess, but I think it's good stile to do
- * so anyway. */
- host_this = host_head;
- host_head = NULL;
- while (host_this != NULL)
- {
- host_next = host_this->next;
-
- csnmp_host_close_session (host_this);
-
- sfree (host_this->name);
- sfree (host_this->address);
- sfree (host_this->community);
- sfree (host_this->data_list);
- sfree (host_this);
-
- host_this = host_next;
- }
+ /* When we get here, the read threads have been stopped and all the
+ * `host_definition_t' will be freed. */
+ DEBUG ("snmp plugin: Destroying all data definitions.");
data_this = data_head;
data_head = NULL;
{
plugin_register_complex_config ("snmp", csnmp_config);
plugin_register_init ("snmp", csnmp_init);
- plugin_register_read ("snmp", csnmp_read);
plugin_register_shutdown ("snmp", csnmp_shutdown);
} /* void module_register */