X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsnmp.c;h=408defa9b4ea385336d66d429d10560422fb6b59;hb=5cdafc6cb9228b93cf9b6956c92df61d00bd2a9e;hp=64f41ada9889a182e0ed89791bacaa3bede20cbc;hpb=97e4d4b708fab4a513476b6462ee562c704bc711;p=collectd.git diff --git a/src/snmp.c b/src/snmp.c index 64f41ada..408defa9 100644 --- a/src/snmp.c +++ b/src/snmp.c @@ -23,6 +23,8 @@ #include "common.h" #include "plugin.h" +#include + #include #include @@ -32,7 +34,7 @@ struct oid_s { oid oid[MAX_OID_LEN]; - uint32_t oid_len; + size_t oid_len; }; typedef struct oid_s oid_t; @@ -49,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; @@ -61,9 +66,17 @@ struct host_definition_s char *address; char *community; int version; - struct snmp_session sess; + void *sess_handle; + 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; @@ -89,8 +102,16 @@ typedef struct csnmp_table_values_s csnmp_table_values_t; /* * Private variables */ -data_definition_t *data_head = NULL; -host_definition_t *host_head = NULL; +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; /* * Private functions @@ -101,13 +122,19 @@ host_definition_t *host_head = NULL; /* * Callgraph for the config stuff: * csnmp_config + * +-> call_snmp_init_once * +-> csnmp_config_add_data * ! +-> 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_collect + * +-> csnmp_config_add_host_address + * +-> csnmp_config_add_host_community + * +-> csnmp_config_add_host_version + * +-> csnmp_config_add_host_collect + * +-> csnmp_config_add_host_interval */ static void call_snmp_init_once (void) { @@ -126,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); @@ -179,6 +204,30 @@ static int csnmp_config_add_data_instance (data_definition_t *dd, oconfig_item_t 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; @@ -196,8 +245,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); @@ -222,6 +271,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; @@ -246,6 +323,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++) { @@ -258,8 +337,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); @@ -291,6 +376,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); @@ -332,8 +418,6 @@ static int csnmp_config_add_host_address (host_definition_t *hd, oconfig_item_t DEBUG ("snmp plugin: host = %s; host->address = %s;", hd->name, hd->address); - hd->sess.peername = hd->address; - return (0); } /* int csnmp_config_add_host_address */ @@ -356,9 +440,6 @@ static int csnmp_config_add_host_community (host_definition_t *hd, oconfig_item_ DEBUG ("snmp plugin: host = %s; host->community = %s;", hd->name, hd->community); - hd->sess.community = (u_char *) hd->community; - hd->sess.community_len = strlen (hd->community); - return (0); } /* int csnmp_config_add_host_community */ @@ -382,11 +463,6 @@ static int csnmp_config_add_host_version (host_definition_t *hd, oconfig_item_t hd->version = version; - if (hd->version == 1) - hd->sess.version = SNMP_VERSION_1; - else - hd->sess.version = SNMP_VERSION_2c; - return (0); } /* int csnmp_config_add_host_address */ @@ -441,6 +517,22 @@ static int csnmp_config_add_host_collect (host_definition_t *host, return (0); } /* int csnmp_config_add_host_collect */ +static int csnmp_config_add_host_interval (host_definition_t *hd, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("snmp plugin: The `Interval' config option needs exactly one number argument."); + return (-1); + } + + hd->interval = (int) ci->values[0].value.number; + if (hd->interval < 0) + hd->interval = 0; + + return (0); +} /* int csnmp_config_add_host_interval */ + static int csnmp_config_add_host (oconfig_item_t *ci) { host_definition_t *hd; @@ -466,8 +558,10 @@ static int csnmp_config_add_host (oconfig_item_t *ci) return (-1); } - snmp_sess_init (&hd->sess); - hd->sess.version = SNMP_VERSION_2c; + hd->sess_handle = NULL; + hd->interval = 0; + hd->next_update = 0; + hd->state = STATE_IDLE; for (i = 0; i < ci->children_num; i++) { @@ -482,6 +576,8 @@ static int csnmp_config_add_host (oconfig_item_t *ci) status = csnmp_config_add_host_version (hd, option); else if (strcasecmp ("Collect", option->key) == 0) csnmp_config_add_host_collect (hd, option); + else if (strcasecmp ("Interval", option->key) == 0) + csnmp_config_add_host_interval (hd, option); else { WARNING ("snmp plugin: csnmp_config_add_host: Option `%s' not allowed here.", option->key); @@ -556,33 +652,47 @@ static int csnmp_config (oconfig_item_t *ci) return (0); } /* int csnmp_config */ -static int csnmp_init (void) +/* End of the config stuff. Now the interesting part begins */ + +static void csnmp_host_close_session (host_definition_t *host) { - call_snmp_init_once (); - return (0); -} + if (host->sess_handle == NULL) + return; -#if 0 -static void csnmp_submit (gauge_t snum, gauge_t mnum, gauge_t lnum) + 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) { - value_t values[3]; - value_list_t vl = VALUE_LIST_INIT; + struct snmp_session sess; - values[0].gauge = snum; - values[1].gauge = mnum; - values[2].gauge = lnum; + if (host->sess_handle != NULL) + csnmp_host_close_session (host); - vl.values = values; - vl.values_len = STATIC_ARRAY_SIZE (values); - vl.time = time (NULL); - strcpy (vl.host, hostname_g); - strcpy (vl.plugin, "load"); + snmp_sess_init (&sess); + sess.peername = host->address; + sess.community = (u_char *) host->community; + sess.community_len = strlen (host->community); + sess.version = (host->version == 1) ? SNMP_VERSION_1 : SNMP_VERSION_2c; - plugin_dispatch_values ("load", &vl); -} -#endif + /* snmp_sess_open will copy the `struct snmp_session *'. */ + host->sess_handle = snmp_sess_open (&sess); + + if (host->sess_handle == NULL) + { + char *errstr = NULL; + + snmp_error (&sess, NULL, NULL, &errstr); -static value_t csnmp_value_list_to_value (struct variable_list *vl, int type) + ERROR ("snmp plugin: host %s: snmp_sess_open failed: %s", + host->name, (errstr == NULL) ? "Unknown problem" : errstr); + sfree (errstr); + } +} /* void csnmp_host_open_session */ + +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; @@ -591,17 +701,20 @@ static value_t csnmp_value_list_to_value (struct variable_list *vl, int type) if ((vl->type == ASN_INTEGER) || (vl->type == ASN_UINTEGER) || (vl->type == ASN_COUNTER) +#ifdef ASN_TIMETICKS + || (vl->type == ASN_TIMETICKS) +#endif || (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 { @@ -617,12 +730,143 @@ 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; + + 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++) + { + 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); + snprintf (il->instance, sizeof (il->instance), + "%llu", val.counter); + } + il->instance[sizeof (il->instance) - 1] = '\0'; + + /* 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) @@ -634,6 +878,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) @@ -643,6 +889,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) @@ -654,46 +902,103 @@ 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.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 + + { + char temp[DATA_MAX_NAME_LEN]; + + if (instance_list_ptr == NULL) + snprintf (temp, sizeof (temp), "%u", + (uint32_t) subid); + else + strncpy (temp, instance_list_ptr->instance, + sizeof (temp)); + temp[sizeof (temp) - 1] = '\0'; + + if (data->instance_prefix == NULL) + strncpy (vl.type_instance, temp, sizeof (vl.type_instance)); + else + snprintf (vl.type_instance, sizeof (vl.type_instance), "%s%s", + data->instance_prefix, temp); + vl.type_instance[sizeof (vl.type_instance) - 1] = '\0'; + } + + 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) */ + + subid++; + } /* while (have_more != 0) */ sfree (vl.values); sfree (value_table_ptr); @@ -701,8 +1006,7 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat return (0); } /* int csnmp_dispatch_table */ -static int csnmp_read_table (struct snmp_session *sess_ptr, - host_definition_t *host, data_definition_t *data) +static int csnmp_read_table (host_definition_t *host, data_definition_t *data) { struct snmp_pdu *req; struct snmp_pdu *res; @@ -723,9 +1027,15 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, csnmp_table_values_t **value_table; csnmp_table_values_t **value_table_ptr; - DEBUG ("snmp plugin: csnmp_read_value (host = %s, data = %s)", + DEBUG ("snmp plugin: csnmp_read_table (host = %s, data = %s)", host->name, data->name); + if (host->sess_handle == NULL) + { + DEBUG ("snmp plugin: csnmp_read_table: host->sess_handle == NULL"); + return (-1); + } + ds = plugin_get_ds (data->type); if (!ds) { @@ -744,20 +1054,26 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, 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); } - memset (value_table, '\0', sizeof (csnmp_table_values_t *) * 2); + memset (value_table, '\0', sizeof (csnmp_table_values_t *) * 2 * data->values_len); value_table_ptr = value_table + data->values_len; instance_list = NULL; @@ -766,8 +1082,6 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, status = 0; while (status == 0) { - csnmp_list_instances_t *il; - req = snmp_pdu_create (SNMP_MSG_GETNEXT); if (req == NULL) { @@ -779,11 +1093,24 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, for (i = 0; i < oid_list_len; i++) snmp_add_null_var (req, oid_list[i].oid, oid_list[i].oid_len); - status = snmp_synch_response (sess_ptr, req, &res); + res = NULL; + status = snmp_sess_synch_response (host->sess_handle, req, &res); - if (status != STAT_SUCCESS) + if ((status != STAT_SUCCESS) || (res == NULL)) { - ERROR ("snmp plugin: snmp_synch_response failed."); + char *errstr = NULL; + + 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); + + if (res != NULL) + snmp_free_pdu (res); + res = NULL; + + sfree (errstr); + csnmp_host_close_session (host); + status = -1; break; } @@ -797,64 +1124,46 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, 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) - 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) { - 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) { - strncpy (il->instance, (char *) vb->val.bitstring, - sizeof (il->instance)); - il->instance[sizeof (il->instance) - 1] = '\0'; - DEBUG ("Before escape_slashes: %s", il->instance); - escape_slashes (il->instance, strlen (il->instance)); - DEBUG ("After escape_slashes: %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; - - for (i = 0; i < data->values_len; i++) - { - csnmp_table_values_t *vt; - - vb = vb->next_variable; - if (vb == NULL) + /* 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) { + 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, @@ -869,35 +1178,45 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, 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; - } /* for (data->values_len) */ + 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) snmp_free_pdu (res); 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); @@ -926,8 +1245,7 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, return (0); } /* int csnmp_read_table */ -static int csnmp_read_value (struct snmp_session *sess_ptr, - host_definition_t *host, data_definition_t *data) +static int csnmp_read_value (host_definition_t *host, data_definition_t *data) { struct snmp_pdu *req; struct snmp_pdu *res; @@ -942,6 +1260,12 @@ static int csnmp_read_value (struct snmp_session *sess_ptr, DEBUG ("snmp plugin: csnmp_read_value (host = %s, data = %s)", host->name, data->name); + if (host->sess_handle == NULL) + { + DEBUG ("snmp plugin: csnmp_read_table: host->sess_handle == NULL"); + return (-1); + } + ds = plugin_get_ds (data->type); if (!ds) { @@ -970,10 +1294,12 @@ static int csnmp_read_value (struct snmp_session *sess_ptr, strncpy (vl.host, host->name, sizeof (vl.host)); vl.host[sizeof (vl.host) - 1] = '\0'; - strcpy (vl.plugin, "snmp"); + sstrncpy (vl.plugin, "snmp", sizeof (vl.plugin)); strncpy (vl.type_instance, data->instance.string, sizeof (vl.type_instance)); vl.type_instance[sizeof (vl.type_instance) - 1] = '\0'; + vl.interval = host->interval; + req = snmp_pdu_create (SNMP_MSG_GET); if (req == NULL) { @@ -984,12 +1310,25 @@ static int csnmp_read_value (struct snmp_session *sess_ptr, for (i = 0; i < data->values_len; i++) snmp_add_null_var (req, data->values[i].oid, data->values[i].oid_len); - status = snmp_synch_response (sess_ptr, req, &res); - if (status != STAT_SUCCESS) + res = NULL; + status = snmp_sess_synch_response (host->sess_handle, req, &res); + + if ((status != STAT_SUCCESS) || (res == NULL)) { - ERROR ("snmp plugin: snmp_synch_response failed."); - sfree (vl.values); + char *errstr = NULL; + + 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); + + if (res != NULL) + snmp_free_pdu (res); + res = NULL; + + sfree (errstr); + csnmp_host_close_session (host); + return (-1); } @@ -997,18 +1336,23 @@ static int csnmp_read_value (struct snmp_session *sess_ptr, for (vb = res->variables; vb != NULL; vb = vb->next_variable) { +#if COLLECT_DEBUG char buffer[1024]; snprint_variable (buffer, sizeof (buffer), 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); + vl.values[i] = csnmp_value_list_to_value (vb, ds->ds[i].type, + data->scale, data->shift); } /* for (res->variables) */ - snmp_free_pdu (res); + 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); @@ -1019,36 +1363,132 @@ static int csnmp_read_value (struct snmp_session *sess_ptr, static int csnmp_read_host (host_definition_t *host) { - struct snmp_session *sess_ptr; int i; + time_t time_start; + time_t time_end; - DEBUG ("snmp plugin: csnmp_read_host (%s);", host->name); + time_start = time (NULL); + DEBUG ("snmp plugin: csnmp_read_host (%s) started at %u;", host->name, + (unsigned int) time_start); - sess_ptr = snmp_open (&host->sess); - if (sess_ptr == NULL) - { - snmp_perror ("snmp_open"); - ERROR ("snmp plugin: snmp_open failed."); + if (host->sess_handle == NULL) + csnmp_host_open_session (host); + + if (host->sess_handle == NULL) return (-1); - } for (i = 0; i < host->data_list_len; i++) { data_definition_t *data = host->data_list[i]; if (data->is_table) - csnmp_read_table (sess_ptr, host, data); + csnmp_read_table (host, data); else - csnmp_read_value (sess_ptr, host, data); + csnmp_read_value (host, data); + } + + time_end = time (NULL); + DEBUG ("snmp plugin: csnmp_read_host (%s) finished at %u;", host->name, + (unsigned int) time_end); + if ((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)); } - snmp_close (sess_ptr); return (0); } /* int csnmp_read_host */ +static void *csnmp_read_thread (void *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 < 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) { @@ -1056,17 +1496,89 @@ static int csnmp_read (void) return (-1); } + now = time (NULL); + + pthread_mutex_lock (&host_lock); for (host = host_head; host != NULL; host = host->next) - csnmp_read_host (host); + { + 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; + } + + data_this = data_head; + data_head = NULL; + while (data_this != NULL) + { + data_next = data_this->next; + + sfree (data_this->name); + sfree (data_this->type); + sfree (data_this->values); + sfree (data_this); + + data_this = data_next; + } + + return (0); +} /* int csnmp_shutdown */ + void module_register (void) { 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 */ /*