X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsnmp.c;h=2c4c930cb652dce0c5f3a7642a12b5f347a561d3;hb=747f853a2ce3f8a55438aff274df5ea25a3e9cce;hp=64f41ada9889a182e0ed89791bacaa3bede20cbc;hpb=e71b0716ca4c0a3df8ffae073d66535a7f61d70e;p=collectd.git diff --git a/src/snmp.c b/src/snmp.c index 64f41ada..2c4c930c 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; @@ -61,9 +63,17 @@ struct host_definition_s char *address; char *community; int version; - struct snmp_session sess; + 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; @@ -89,8 +99,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 +119,18 @@ 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_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) { @@ -332,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 */ @@ -356,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 */ @@ -382,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 */ @@ -441,6 +454,25 @@ 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) +{ + int interval; + + 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); + } + + interval = (int) ci->values[0].value.number; + hd->skip_num = interval; + if (hd->skip_num < 0) + hd->skip_num = 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 +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->sess_handle = NULL; + hd->skip_num = 0; + hd->skip_left = 0; + hd->state = STATE_IDLE; for (i = 0; i < ci->children_num; i++) { @@ -482,6 +516,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,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: snmp_sess_close failed: %s", + (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; + + /* 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); - plugin_dispatch_values ("load", &vl); -} -#endif + ERROR ("snmp plugin: snmp_sess_open failed: %s", + (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) { @@ -662,6 +725,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; @@ -701,8 +765,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,7 +786,7 @@ 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); ds = plugin_get_ds (data->type); @@ -757,7 +820,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; @@ -779,11 +842,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: snmp_sess_synch_response failed: %s", + (errstr == NULL) ? "Unknown problem" : errstr); + csnmp_host_close_session (host); + status = -1; break; } @@ -817,12 +886,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 { @@ -891,7 +975,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); @@ -926,8 +1010,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; @@ -974,6 +1057,8 @@ 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 = host->skip_num; + req = snmp_pdu_create (SNMP_MSG_GET); if (req == NULL) { @@ -984,12 +1069,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: snmp_sess_synch_response failed: %s", + (errstr == NULL) ? "Unknown problem" : errstr); + csnmp_host_close_session (host); + sfree (errstr); + return (-1); } @@ -1019,36 +1110,112 @@ 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) + 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) + 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 +1223,90 @@ 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; + + 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 */ /*