X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsnmp.c;h=3c8a4fcb88299dea02357f76c24377e355f20f83;hb=51ed8fc1a698fbfd1d557d7615228c32dcbc2105;hp=ec4a696c7ced5c98e88b83933e72000e504847da;hpb=63cbff115ba03717e81087d1419fc07c24d205c2;p=collectd.git diff --git a/src/snmp.c b/src/snmp.c index ec4a696c..3c8a4fcb 100644 --- a/src/snmp.c +++ b/src/snmp.c @@ -23,6 +23,8 @@ #include "common.h" #include "plugin.h" +#include + #include #include @@ -61,11 +63,17 @@ struct host_definition_s char *address; char *community; int version; - struct snmp_session sess; - uint16_t skip_num; - uint16_t skip_left; + void *sess_handle; + int16_t skip_num; + int16_t skip_left; data_definition_t **data_list; int data_list_len; + enum /****************************************************/ + { /* This host.. */ + STATE_IDLE, /* - just sits there until `skip_left < 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; @@ -91,9 +99,17 @@ typedef struct csnmp_table_values_s csnmp_table_values_t; /* * 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; + /* * Private functions */ @@ -339,8 +355,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 */ @@ -363,9 +377,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 */ @@ -389,11 +400,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 */ @@ -460,15 +466,9 @@ static int csnmp_config_add_host_interval (host_definition_t *hd, oconfig_item_t } interval = (int) ci->values[0].value.number; - hd->skip_num = interval / interval_g; - if (hd->skip_num < 1) - hd->skip_num = 1; - - if ((hd->skip_num * interval_g) != interval) - { - WARNING ("snmp plugin: Data for host `%s' will be collected every %i seconds.", - hd->name, hd->skip_num * interval_g); - } + hd->skip_num = interval; + if (hd->skip_num < 0) + hd->skip_num = 0; return (0); } /* int csnmp_config_add_host_interval */ @@ -498,11 +498,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->skip_num = 1; + hd->sess_handle = NULL; + hd->skip_num = 0; hd->skip_left = 0; + hd->state = STATE_IDLE; for (i = 0; i < ci->children_num; i++) { @@ -593,31 +592,58 @@ 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); -} + int status; + + if (host->sess_handle == NULL) + return; + + status = snmp_sess_close (host->sess_handle); + + if (status != 0) + { + char *errstr = NULL; + + snmp_sess_error (host->sess_handle, NULL, NULL, &errstr); -#if 0 -static void csnmp_submit (gauge_t snum, gauge_t mnum, gauge_t lnum) + ERROR ("snmp plugin: host %s: snmp_sess_close failed: %s", + host->name, (errstr == NULL) ? "Unknown problem" : errstr); + sfree (errstr); + } + + 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); + + 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) { @@ -628,6 +654,9 @@ 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; @@ -699,6 +728,7 @@ static int csnmp_dispatch_table (host_definition_t *host, data_definition_t *dat vl.host[sizeof (vl.host) - 1] = '\0'; strcpy (vl.plugin, "snmp"); + vl.interval = host->skip_num; vl.time = time (NULL); for (instance_list_ptr = instance_list; @@ -738,8 +768,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; @@ -760,9 +789,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) { @@ -794,7 +829,7 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, 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; @@ -816,11 +851,17 @@ 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); + status = snmp_sess_synch_response (host->sess_handle, req, &res); if (status != STAT_SUCCESS) { - 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); + csnmp_host_close_session (host); + status = -1; break; } @@ -854,12 +895,27 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, /* Get instance name */ if ((vb->type == ASN_OCTET_STR) || (vb->type == ASN_BIT_STR)) { - 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); + 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 { @@ -928,7 +984,7 @@ static int csnmp_read_table (struct snmp_session *sess_ptr, /* 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) */ + } /* for (i = data->values_len) */ if (res != NULL) snmp_free_pdu (res); @@ -963,8 +1019,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; @@ -979,6 +1034,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) { @@ -1011,7 +1072,7 @@ static int csnmp_read_value (struct snmp_session *sess_ptr, strncpy (vl.type_instance, data->instance.string, sizeof (vl.type_instance)); vl.type_instance[sizeof (vl.type_instance) - 1] = '\0'; - vl.interval = interval_g * host->skip_num; + vl.interval = host->skip_num; req = snmp_pdu_create (SNMP_MSG_GET); if (req == NULL) @@ -1023,12 +1084,18 @@ 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); + status = snmp_sess_synch_response (host->sess_handle, req, &res); if (status != STAT_SUCCESS) { - 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); + csnmp_host_close_session (host); + sfree (errstr); + return (-1); } @@ -1058,33 +1125,114 @@ 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; DEBUG ("snmp plugin: csnmp_read_host (%s);", host->name); - 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); } - 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 `skip_num' here, because `interval_g' isn't + * initialized during `configure'. */ + host->skip_left = interval_g; + if (host->skip_num == 0) + { + host->skip_num = interval_g; + } + else if (host->skip_num < interval_g) + { + host->skip_num = interval_g; + WARNING ("snmp plugin: Data for host `%s' will be collected every %i seconds.", + host->name, host->skip_num); + } + + 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; @@ -1098,25 +1246,88 @@ static int csnmp_read (void) now = time (NULL); + pthread_mutex_lock (&host_lock); for (host = host_head; host != NULL; host = host->next) { - host->skip_left--; - if (host->skip_left > 0) + if (host->state != STATE_IDLE) continue; - csnmp_read_host (host); + host->skip_left -= interval_g; + if (host->skip_left >= interval_g) + continue; + + host->state = STATE_WAIT; host->skip_left = host->skip_num; } /* 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 */ /*