static int agg_config_handle_group_by (oconfig_item_t const *ci, /* {{{ */
aggregation_t *agg)
{
- int i;
-
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
char const *value;
aggregation_t *agg;
_Bool is_valid;
int status;
- int i;
agg = calloc (1, sizeof (*agg));
if (agg == NULL)
sstrncpy (agg->ident.type_instance, "/.*/",
sizeof (agg->ident.type_instance));
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int agg_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
pthread_mutex_lock (&agg_instance_list_lock);
if (lookup == NULL)
}
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int agg_read (void) /* {{{ */
{
- agg_instance_t *this;
cdtime_t t;
int success;
return (0);
}
- for (this = agg_instance_list_head; this != NULL; this = this->next)
+ for (agg_instance_t *this = agg_instance_list_head; this != NULL; this = this->next)
{
int status;
static int camqp_shutdown (void) /* {{{ */
{
- size_t i;
-
DEBUG ("amqp plugin: Shutting down %zu subscriber threads.",
subscriber_threads_num);
subscriber_threads_running = 0;
- for (i = 0; i < subscriber_threads_num; i++)
+ for (size_t i = 0; i < subscriber_threads_num; i++)
{
/* FIXME: Sending a signal is not very elegant here. Maybe find out how
* to use a timeout in the thread and check for the variable in regular
}
else
{
- size_t i;
ssnprintf (routing_key, sizeof (routing_key), "collectd/%s/%s/%s/%s/%s",
vl->host,
vl->plugin, vl->plugin_instance,
/* Switch slashes (the only character forbidden by collectd) and dots
* (the separation character used by AMQP). */
- for (i = 0; routing_key[i] != 0; i++)
+ for (size_t i = 0; routing_key[i] != 0; i++)
{
if (routing_key[i] == '.')
routing_key[i] = '/';
{
camqp_config_t *conf;
int status;
- int i;
conf = calloc (1, sizeof (*conf));
if (conf == NULL)
return (status);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int camqp_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int config_add (oconfig_item_t *ci)
{
apache_t *st;
- int i;
int status;
st = calloc (1, sizeof (*st));
}
assert (st->name != NULL);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int config (oconfig_item_t *ci)
{
int status = 0;
- int i;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
long long response_start = 0LL;
long long response_end = 0LL;
- int i;
- for (i = 0; buf[i] != '\0'; i++)
+ for (int i = 0; buf[i] != '\0'; i++)
{
if (buf[i] == '.') open++;
else if (buf[i] == '_') waiting++;
static int apcups_config (oconfig_item_t *ci)
{
- int i;
_Bool persistent_conn_set = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
char inst[128];
int value_int;
double value_double;
- int i;
-
if (!io_master_port || (io_master_port == MACH_PORT_NULL))
return (-1);
kCFStringEncodingASCII))
continue;
inst[sizeof (inst) - 1] = '\0';
- for (i = 0; i < 128; i++)
+ for (int i = 0; i < 128; i++)
{
if (inst[i] == '\0')
break;
static int aquaero_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
const char *type_instance_prefix, double *value_array, int len)
{
char type_instance[DATA_MAX_NAME_LEN];
- int i;
- for (i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
{
if (value_array[i] == AQ5_FLOAT_UNDEF)
continue;
aq5_settings_t aq_sett;
char *err_msg = NULL;
char type_instance[DATA_MAX_NAME_LEN];
- int i;
if (libaquaero5_poll(conf_device, &aq_data, &err_msg) < 0)
{
AQ5_NUM_OTHER_SENSORS);
/* Fans */
- for (i = 0; i < AQ5_NUM_FAN; i++)
+ for (int i = 0; i < AQ5_NUM_FAN; i++)
{
if ((aq_sett.fan_data_source[i] == NONE)
|| (aq_data.fan_vrm_temp[i] != AQ5_FLOAT_UNDEF))
static int ascent_submit_players (player_stats_t *ps) /* {{{ */
{
- size_t i;
gauge_t value;
- for (i = 0; i < RACES_LIST_LENGTH; i++)
+ for (size_t i = 0; i < RACES_LIST_LENGTH; i++)
if (races_list[i] != NULL)
ascent_submit_gauge ("by-race", "players", races_list[i],
(gauge_t) ps->races[i]);
- for (i = 0; i < CLASSES_LIST_LENGTH; i++)
+ for (size_t i = 0; i < CLASSES_LIST_LENGTH; i++)
if (classes_list[i] != NULL)
ascent_submit_gauge ("by-class", "players", classes_list[i],
(gauge_t) ps->classes[i]);
- for (i = 0; i < GENDERS_LIST_LENGTH; i++)
+ for (size_t i = 0; i < GENDERS_LIST_LENGTH; i++)
if (genders_list[i] != NULL)
ascent_submit_gauge ("by-gender", "players", genders_list[i],
(gauge_t) ps->genders[i]);
static int ascent_xml_sessions_plr (xmlDoc *doc, xmlNode *node, /* {{{ */
player_info_t *pi)
{
- xmlNode *child;
-
- for (child = node->xmlChildrenNode; child != NULL; child = child->next)
+ for (xmlNode *child = node->xmlChildrenNode; child != NULL; child = child->next)
{
if ((xmlStrcmp ((const xmlChar *) "comment", child->name) == 0)
|| (xmlStrcmp ((const xmlChar *) "text", child->name) == 0))
static int ascent_xml_sessions (xmlDoc *doc, xmlNode *node) /* {{{ */
{
- xmlNode *child;
player_stats_t ps = {
.level_sum = 0
};
- for (child = node->xmlChildrenNode; child != NULL; child = child->next)
+ for (xmlNode *child = node->xmlChildrenNode; child != NULL; child = child->next)
{
if ((xmlStrcmp ((const xmlChar *) "comment", child->name) == 0)
|| (xmlStrcmp ((const xmlChar *) "text", child->name) == 0))
static int ascent_xml_status (xmlDoc *doc, xmlNode *node) /* {{{ */
{
- xmlNode *child;
-
- for (child = node->xmlChildrenNode; child != NULL; child = child->next)
+ for (xmlNode *child = node->xmlChildrenNode; child != NULL; child = child->next)
{
if ((xmlStrcmp ((const xmlChar *) "comment", child->name) == 0)
|| (xmlStrcmp ((const xmlChar *) "text", child->name) == 0))
{
xmlDoc *doc;
xmlNode *cur;
- xmlNode *child;
#if 0
doc = xmlParseMemory (data, strlen (data),
return (-1);
}
- for (child = cur->xmlChildrenNode; child != NULL; child = child->next)
+ for (xmlNode *child = cur->xmlChildrenNode; child != NULL; child = child->next)
{
if ((xmlStrcmp ((const xmlChar *) "comment", child->name) == 0)
|| (xmlStrcmp ((const xmlChar *) "text", child->name) == 0))
gauge_t * values = NULL; /**< rate values */
size_t values_num = 0; /**< number of rate values */
- size_t i;
gauge_t values_history[REF_TEMP_AVG_NUM];
list->initialized = 1;
list->num_values = values_num;
- for(i=0; i<values_num; ++i)
+ for(size_t i=0; i<values_num; ++i)
{
DEBUG ("barometer: get_reference_temperature - rate %zu: %lf **",
i, values[i]);
continue;
}
- for(i=0; i<REF_TEMP_AVG_NUM*list->num_values; ++i)
+ for(size_t i=0; i<REF_TEMP_AVG_NUM*list->num_values; ++i)
{
DEBUG ("barometer: get_reference_temperature - history %zu: %lf",
i, values_history[i]);
continue;
}
- for(i=0; i<values_num; ++i)
+ for(size_t i=0; i<values_num; ++i)
{
DEBUG ("barometer: get_reference_temperature - rate last %zu: %lf **",
i, values[i]);
already available. */
if(!avg_initialized)
{
- int i;
- for(i=0; i<config_oversample-1; ++i)
+ for(int i=0; i<config_oversample-1; ++i)
{
result = MPL115_read_averaged(&pressure, &temperature);
if(result)
CFTypeRef ps_obj;
double temp_double;
- int i;
ps_raw = IOPSCopyPowerSourcesInfo ();
ps_array = IOPSCopyPowerSourcesList (ps_raw);
DEBUG ("ps_array_len == %i", ps_array_len);
- for (i = 0; i < ps_array_len; i++)
+ for (int i = 0; i < ps_array_len; i++)
{
ps_obj = CFArrayGetValueAtIndex (ps_array, i);
ps_dict = IOPSGetPowerSourceDescription (ps_raw, ps_obj);
CFDictionaryRef bat_root_dict;
CFArrayRef bat_info_arry;
CFIndex bat_info_arry_len;
- CFIndex bat_info_arry_pos;
CFDictionaryRef bat_info_dict;
double temp_double;
}
bat_info_arry_len = CFArrayGetCount (bat_info_arry);
- for (bat_info_arry_pos = 0;
+ for (CFIndex bat_info_arry_pos = 0;
bat_info_arry_pos < bat_info_arry_len;
bat_info_arry_pos++)
{
static int read_pmu (void) /* {{{ */
{
- int i;
-
+ int i = 0;
/* The upper limit here is just a safeguard. If there is a system with
* more than 100 batteries, this can easily be increased. */
- for (i = 0; i < 100; i++)
+ for (; i < 100; i++)
{
FILE *fh;
static int battery_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
time_t current_time, void *user_data)
{
translation_table_ptr_t *table = (translation_table_ptr_t *) user_data;
- size_t i;
if (table == NULL)
return (-1);
- for (i = 0; i < table->table_length; i++)
+ for (size_t i = 0; i < table->table_length; i++)
{
if (strcmp (table->table[i].xml_name, name) != 0)
continue;
{
xmlXPathObject *xpathObj = NULL;
int num_entries;
- int i;
xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
if (xpathObj == NULL)
num_entries = 0;
/* Iterate over all matching nodes. */
- for (i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr); i++)
+ for (int i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr); i++)
{
xmlNode *name_node = NULL;
xmlNode *counter = NULL;
xmlNode *parent;
- xmlNode *child;
parent = xpathObj->nodesetval->nodeTab[i];
DEBUG ("bind plugin: bind_parse_generic_name_value: parent->name = %s;",
(char *) parent->name);
/* Iterate over all child nodes. */
- for (child = parent->xmlChildrenNode;
+ for (xmlNode *child = parent->xmlChildrenNode;
child != NULL;
child = child->next)
{
{
xmlXPathObject *xpathObj = NULL;
int num_entries;
- int i;
xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
if (xpathObj == NULL)
num_entries = 0;
/* Iterate over all matching nodes. */
- for (i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr); i++)
+ for (int i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr); i++)
{
- xmlNode *child;
-
/* Iterate over all child nodes. */
- for (child = xpathObj->nodesetval->nodeTab[i]->xmlChildrenNode;
+ for (xmlNode *child = xpathObj->nodesetval->nodeTab[i]->xmlChildrenNode;
child != NULL;
child = child->next)
{
{
xmlXPathObject *xpathObj = NULL;
int num_entries;
- int i;
xpathObj = xmlXPathEvalExpression(BAD_CAST xpath_expression, xpathCtx);
if (xpathObj == NULL)
num_entries = 0;
/* Iterate over all matching nodes. */
- for (i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr); i++)
+ for (int i = 0; xpathObj->nodesetval && (i < xpathObj->nodesetval->nodeNr); i++)
{
- xmlNode *child;
-
/* Iterate over all child nodes. */
- for (child = xpathObj->nodesetval->nodeTab[i]->xmlChildrenNode;
+ for (xmlNode *child = xpathObj->nodesetval->nodeTab[i]->xmlChildrenNode;
child != NULL;
child = child->next)
{
{
xmlXPathObject *path_obj;
char *zone_name = NULL;
- int i;
size_t j;
if (version >= 3)
return (-1);
}
- for (i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr); i++)
+ for (int i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr); i++)
{
zone_name = (char *) xmlNodeListGetString (doc,
path_obj->nodesetval->nodeTab[i]->xmlChildrenNode, 1);
{
xmlXPathObject *zone_nodes = NULL;
xmlXPathContext *zone_path_context;
- int i;
zone_path_context = xmlXPathNewContext (doc);
if (zone_path_context == NULL)
return (-1);
}
- for (i = 0; i < zone_nodes->nodesetval->nodeNr; i++)
+ for (int i = 0; i < zone_nodes->nodesetval->nodeNr; i++)
{
node = zone_nodes->nodesetval->nodeTab[i];
assert (node != NULL);
{
char *view_name = NULL;
cb_view_t *view;
- int i;
size_t j;
if (version == 3)
return (-1);
}
- for (i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr); i++)
+ for (int i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr); i++)
{
view_name = (char *) xmlNodeListGetString (doc,
path_obj->nodesetval->nodeTab[i]->xmlChildrenNode, 1);
{
xmlXPathObject *view_nodes = NULL;
xmlXPathContext *view_path_context;
- int i;
view_path_context = xmlXPathNewContext (doc);
if (view_path_context == NULL)
return (-1);
}
- for (i = 0; i < view_nodes->nodesetval->nodeNr; i++)
+ for (int i = 0; i < view_nodes->nodesetval->nodeNr; i++)
{
xmlNode *node;
xmlXPathContext *xpathCtx = NULL;
xmlXPathObject *xpathObj = NULL;
int ret = -1;
- int i;
doc = xmlParseMemory (data, strlen (data));
if (doc == NULL)
}
else
{
- for (i = 0; i < xpathObj->nodesetval->nodeNr; i++)
+ for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++)
{
xmlNode *node;
char *attr_version;
return (-1);
}
- for (i = 0; i < xpathObj->nodesetval->nodeNr; i++)
+ for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++)
{
xmlNode *node;
char *attr_version;
static int bind_config_add_view (oconfig_item_t *ci) /* {{{ */
{
cb_view_t *tmp;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
return (-1);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int bind_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
char buffer[number_len+1];
char key[2 * DATA_MAX_NAME_LEN];
_Bool latency_type = 0;
- size_t i;
int status;
key[0] = '\0';
memcpy(buffer, number_val, number_len);
buffer[sizeof(buffer) - 1] = '\0';
- for (i = 0; i < state->depth; i++)
+ for (size_t i = 0; i < state->depth; i++)
{
if (state->stack[i] == NULL)
continue;
static void ceph_daemons_print(void)
{
- int i;
- for(i = 0; i < g_num_daemons; ++i)
+ for(int i = 0; i < g_num_daemons; ++i)
{
ceph_daemon_print(g_daemons[i]);
}
static void ceph_daemon_free(struct ceph_daemon *d)
{
- int i = 0;
- for(; i < d->last_idx; i++)
+ for(int i = 0; i < d->last_idx; i++)
{
sfree(d->last_poll_data[i]);
}
sfree(d->last_poll_data);
d->last_poll_data = NULL;
d->last_idx = 0;
- for(i = 0; i < d->ds_num; i++)
+
+ for(int i = 0; i < d->ds_num; i++)
{
sfree(d->ds_names[i]);
}
/* count_parts returns the number of elements a "foo.bar.baz" style key has. */
static size_t count_parts (char const *key)
{
- char const *ptr;
size_t parts_num = 0;
- for (ptr = key; ptr != NULL; ptr = strchr (ptr + 1, '.'))
+ for (const char *ptr = key; ptr != NULL; ptr = strchr (ptr + 1, '.'))
parts_num++;
return parts_num;
static int cc_add_daemon_config(oconfig_item_t *ci)
{
- int ret, i;
+ int ret;
struct ceph_daemon *nd, cd = { 0 };
struct ceph_daemon **tmp;
return ret;
}
- for(i=0; i < ci->children_num; i++)
+ for(int i=0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int ceph_config(oconfig_item_t *ci)
{
- int ret, i;
+ int ret;
- for(i = 0; i < ci->children_num; ++i)
+ for(int i = 0; i < ci->children_num; ++i)
{
oconfig_item_t *child = ci->children + i;
if(strcasecmp("Daemon", child->key) == 0)
*/
static int backup_search_for_last_avg(struct ceph_daemon *d, const char *ds_n)
{
- int i = 0;
- for(; i < d->last_idx; i++)
+ for(int i = 0; i < d->last_idx; i++)
{
if(strcmp(d->last_poll_data[i]->ds_name, ds_n) == 0)
{
*/
static uint32_t backup_search_for_type(struct ceph_daemon *d, char *ds_name)
{
- int idx = 0;
- for(; idx < d->ds_num; idx++)
+ for(int i = 0; i < d->ds_num; i++)
{
- if(strcmp(d->ds_names[idx], ds_name) == 0)
+ if(strcmp(d->ds_names[i], ds_name) == 0)
{
- return d->ds_types[idx];
+ return d->ds_types[i];
}
}
return DSET_TYPE_UNFOUND;
*/
static int cconn_main_loop(uint32_t request_type)
{
- int i, ret, some_unreachable = 0;
+ int ret, some_unreachable = 0;
struct timeval end_tv;
struct cconn io_array[g_num_daemons];
/* create cconn array */
memset(io_array, 0, sizeof(io_array));
- for(i = 0; i < g_num_daemons; ++i)
+ for(int i = 0; i < g_num_daemons; ++i)
{
io_array[i].d = g_daemons[i];
io_array[i].request_type = request_type;
struct pollfd fds[g_num_daemons];
memset(fds, 0, sizeof(fds));
nfds = 0;
- for(i = 0; i < g_num_daemons; ++i)
+ for(int i = 0; i < g_num_daemons; ++i)
{
struct cconn *io = io_array + i;
ret = cconn_prepare(io, fds + nfds);
ERROR("ceph plugin: poll(2) error: %d", ret);
goto done;
}
- for(i = 0; i < nfds; ++i)
+ for(int i = 0; i < nfds; ++i)
{
struct cconn *io = polled_io_array[i];
int revents = fds[i].revents;
}
}
}
- done: for(i = 0; i < g_num_daemons; ++i)
+ done: for(int i = 0; i < g_num_daemons; ++i)
{
cconn_close(io_array + i);
}
static int ceph_shutdown(void)
{
- int i;
- for(i = 0; i < g_num_daemons; ++i)
+ for(int i = 0; i < g_num_daemons; ++i)
{
ceph_daemon_free(g_daemons[i]);
}
static int cgroups_read (void)
{
- cu_mount_t *mnt_list;
- cu_mount_t *mnt_ptr;
+ cu_mount_t *mnt_list = NULL;
_Bool cgroup_found = 0;
- mnt_list = NULL;
if (cu_mount_getlist (&mnt_list) == NULL)
{
ERROR ("cgroups plugin: cu_mount_getlist failed.");
return (-1);
}
- for (mnt_ptr = mnt_list; mnt_ptr != NULL; mnt_ptr = mnt_ptr->next)
+ for (cu_mount_t *mnt_ptr = mnt_list; mnt_ptr != NULL; mnt_ptr = mnt_ptr->next)
{
/* Find the cgroup mountpoint which contains the cpuacct
* controller. */
{
/* collectd read callback: Perform data acquisition */
int rc;
- unsigned int now_src, n_sources;
+ unsigned int n_sources;
if (g_chrony_seq_is_initialized == 0)
{
if (rc != CHRONY_RC_OK)
return rc;
- for (now_src = 0; now_src < n_sources; ++now_src)
+ for (unsigned int now_src = 0; now_src < n_sources; ++now_src)
{
int is_reachable;
rc = chrony_request_source_data(now_src, &is_reachable);
gauge_t *new_values;
char **new_names;
- size_t i;
-
if (match_ds_g == NULL)
return (RET_OKAY);
return (RET_UNKNOWN);
}
- for (i = 0; i < match_ds_num_g; i++)
+ for (size_t i = 0; i < match_ds_num_g; i++)
{
size_t j;
}
free (*values);
- for (i = 0; i < *values_num; i++)
+ for (size_t i = 0; i < *values_num; i++)
free ((*values_names)[i]);
free (*values_names);
char *hostname = NULL;
int status;
- size_t i;
status = lcc_listval (connection, &ret_ident, &ret_ident_num);
if (status != 0) {
return (RET_UNKNOWN);
}
- for (i = 0; i < ret_ident_num; ++i) {
+ for (size_t i = 0; i < ret_ident_num; ++i) {
char id[1024];
if ((hostname_g != NULL) && (strcasecmp (hostname_g, ret_ident[i].host)))
int num_okay = 0;
const char *status_str = "UNKNOWN";
int status_code = RET_UNKNOWN;
- size_t i;
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
{
if (isnan (values[i]))
{
if (values_num > 0)
{
printf (" |");
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
printf (" %s=%f;;;;", values_names[i], values[i]);
}
printf ("\n");
static int do_check_con_average (size_t values_num,
double *values, char **values_names)
{
- size_t i;
double total;
int total_num;
double average;
total = 0.0;
total_num = 0;
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
{
if (isnan (values[i]))
{
}
printf ("%s: %g average |", status_str, average);
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
printf (" %s=%f;;;;", values_names[i], values[i]);
printf ("\n");
static int do_check_con_sum (size_t values_num,
double *values, char **values_names)
{
- size_t i;
double total;
int total_num;
const char *status_str = "UNKNOWN";
total = 0.0;
total_num = 0;
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
{
if (isnan (values[i]))
{
}
printf ("%s: %g sum |", status_str, total);
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
printf (" %s=%f;;;;", values_names[i], values[i]);
printf ("\n");
static int do_check_con_percentage (size_t values_num,
double *values, char **values_names)
{
- size_t i;
double sum = 0.0;
double percentage;
return (RET_WARNING);
}
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
{
if (isnan (values[i]))
{
}
printf ("%s: %lf percent |", status_str, percentage);
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
printf (" %s=%lf;;;;", values_names[i], values[i]);
return (status_code);
} /* int do_check_con_percentage */
size_t values_num;
char ident_str[1024];
lcc_identifier_t ident;
- size_t i;
int status;
snprintf (ident_str, sizeof (ident_str), "%s/%s",
free (values);
if (values_names != NULL)
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
free (values_names[i]);
free (values_names);
int main (int argc, char **argv) /* {{{ */
{
- int i;
double last_time;
int values_sent = 0;
fprintf (stdout, "Creating %i values ... ", conf_num_values);
fflush (stdout);
- for (i = 0; i < conf_num_values; i++)
+ for (int i = 0; i < conf_num_values; i++)
{
lcc_value_list_t *vl;
char **ret_values_names = NULL;
int status;
- size_t i;
assert (strcasecmp (argv[0], "getval") == 0);
if (ret_values != NULL) \
free (ret_values); \
if (ret_values_names != NULL) { \
- for (i = 0; i < ret_values_num; ++i) \
+ for (size_t i = 0; i < ret_values_num; ++i) \
free (ret_values_names[i]); \
free (ret_values_names); \
} \
BAIL_OUT (-1);
}
- for (i = 0; i < ret_values_num; ++i)
+ for (size_t i = 0; i < ret_values_num; ++i)
printf ("%s=%e\n", ret_values_names[i], ret_values[i]);
BAIL_OUT (0);
#undef BAIL_OUT
size_t plugins_num = 0;
int status;
- int i;
assert (strcasecmp (argv[0], "flush") == 0);
return (s); \
} while (0)
- for (i = 1; i < argc; ++i) {
+ for (int i = 1; i < argc; ++i) {
char *key, *value;
key = argv[i];
plugins[0] = NULL;
}
- for (i = 0; i < plugins_num; ++i) {
+ for (int i = 0; i < plugins_num; ++i) {
if (identifiers_num == 0) {
status = lcc_flush (c, plugins[i], NULL, timeout);
if (status != 0)
(plugins[i] == NULL) ? "(all)" : plugins[i], lcc_strerror (c));
}
else {
- int j;
-
- for (j = 0; j < identifiers_num; ++j) {
+ for (int j = 0; j < identifiers_num; ++j) {
status = lcc_flush (c, plugins[i], identifiers + j, timeout);
if (status != 0) {
char id[1024];
size_t ret_ident_num = 0;
int status;
- size_t i;
assert (strcasecmp (argv[0], "listval") == 0);
BAIL_OUT (status);
}
- for (i = 0; i < ret_ident_num; ++i) {
+ for (size_t i = 0; i < ret_ident_num; ++i) {
char id[1024];
status = lcc_identifier_to_string (c, id, sizeof (id), ret_ident + i);
size_t values_len = 0;
int status;
- int i;
assert (strcasecmp (argv[0], "putval") == 0);
if (status != 0)
return (status);
- for (i = 2; i < argc; ++i) {
+ for (int i = 2; i < argc; ++i) {
char *tmp;
tmp = strchr (argv[i], (int)'=');
* array. */
static void aggregate (gauge_t *sum_by_state) /* {{{ */
{
- size_t cpu_num;
- size_t state;
-
- for (state = 0; state < COLLECTD_CPU_STATE_MAX; state++)
+ for (size_t state = 0; state < COLLECTD_CPU_STATE_MAX; state++)
sum_by_state[state] = NAN;
- for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
+ for (size_t cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
{
cpu_state_t *this_cpu_states = get_cpu_state (cpu_num, 0);
this_cpu_states[COLLECTD_CPU_STATE_ACTIVE].rate = NAN;
- for (state = 0; state < COLLECTD_CPU_STATE_ACTIVE; state++)
+ for (size_t state = 0; state < COLLECTD_CPU_STATE_ACTIVE; state++)
{
if (!this_cpu_states[state].has_value)
continue;
static void cpu_commit_one (int cpu_num, /* {{{ */
gauge_t rates[static COLLECTD_CPU_STATE_MAX])
{
- size_t state;
gauge_t sum;
sum = rates[COLLECTD_CPU_STATE_ACTIVE];
return;
}
- for (state = 0; state < COLLECTD_CPU_STATE_ACTIVE; state++)
+ for (size_t state = 0; state < COLLECTD_CPU_STATE_ACTIVE; state++)
{
gauge_t percent = 100.0 * rates[state] / sum;
submit_percent (cpu_num, state, percent);
* each iteration / after each call to cpu_commit(). */
static void cpu_reset (void) /* {{{ */
{
- size_t i;
-
- for (i = 0; i < cpu_states_num; i++)
+ for (size_t i = 0; i < cpu_states_num; i++)
cpu_states[i].has_value = 0;
global_cpu_num = 0;
/* Legacy behavior: Dispatches the raw derive values without any aggregation. */
static void cpu_commit_without_aggregation (void) /* {{{ */
{
- int state;
-
- for (state = 0; state < COLLECTD_CPU_STATE_ACTIVE; state++)
+ for (int state = 0; state < COLLECTD_CPU_STATE_ACTIVE; state++)
{
- size_t cpu_num;
-
- for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
+ for (size_t cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
{
cpu_state_t *s = get_cpu_state (cpu_num, state);
gauge_t global_rates[COLLECTD_CPU_STATE_MAX] = {
NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN /* Batman! */
};
- size_t cpu_num;
if (report_by_state && report_by_cpu && !report_percent)
{
return;
}
- for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
+ for (size_t cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
{
cpu_state_t *this_cpu_states = get_cpu_state (cpu_num, 0);
gauge_t local_rates[COLLECTD_CPU_STATE_MAX] = {
NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN
};
- size_t state;
- for (state = 0; state < COLLECTD_CPU_STATE_MAX; state++)
+ for (size_t state = 0; state < COLLECTD_CPU_STATE_MAX; state++)
if (this_cpu_states[state].has_value)
local_rates[state] = this_cpu_states[state].rate;
cdtime_t now = cdtime ();
#if PROCESSOR_CPU_LOAD_INFO /* {{{ */
- int cpu;
-
kern_return_t status;
processor_cpu_load_info_data_t cpu_info;
host_t cpu_host;
- for (cpu = 0; cpu < cpu_list_len; cpu++)
+ for (int cpu = 0; cpu < cpu_list_len; cpu++)
{
cpu_host = 0;
cpu_info_len = PROCESSOR_BASIC_INFO_COUNT;
/* }}} #endif defined(KERNEL_LINUX) */
#elif defined(HAVE_LIBKSTAT) /* {{{ */
- int cpu;
static cpu_stat_t cs;
if (kc == NULL)
return (-1);
- for (cpu = 0; cpu < numcpu; cpu++)
+ for (int cpu = 0; cpu < numcpu; cpu++)
{
if (kstat_read (kc, ksp[cpu], &cs) == -1)
continue; /* error message? */
uint64_t cpuinfo[numcpu][CPUSTATES];
size_t cpuinfo_size;
int status;
- int i;
if (numcpu < 1)
{
#if defined(KERN_CPTIME2)
if (numcpu > 1) {
- for (i = 0; i < numcpu; i++) {
+ for (int i = 0; i < numcpu; i++) {
int mib[] = {CTL_KERN, KERN_CPTIME2, i};
cpuinfo_size = sizeof (cpuinfo[0]);
return (-1);
}
- for(i = 0; i < CPUSTATES; i++) {
+ for(int i = 0; i < CPUSTATES; i++) {
cpuinfo[0][i] = cpuinfo_tmp[i];
}
}
- for (i = 0; i < numcpu; i++) {
+ for (int i = 0; i < numcpu; i++) {
cpu_stage (i, COLLECTD_CPU_STATE_USER, (derive_t) cpuinfo[i][CP_USER], now);
cpu_stage (i, COLLECTD_CPU_STATE_NICE, (derive_t) cpuinfo[i][CP_NICE], now);
cpu_stage (i, COLLECTD_CPU_STATE_SYSTEM, (derive_t) cpuinfo[i][CP_SYS], now);
#elif defined(HAVE_SYSCTLBYNAME) && defined(HAVE_SYSCTL_KERN_CP_TIMES) /* {{{ */
long cpuinfo[maxcpu][CPUSTATES];
size_t cpuinfo_size;
- int i;
memset (cpuinfo, 0, sizeof (cpuinfo));
return (-1);
}
- for (i = 0; i < numcpu; i++) {
+ for (int i = 0; i < numcpu; i++) {
cpu_stage (i, COLLECTD_CPU_STATE_USER, (derive_t) cpuinfo[i][CP_USER], now);
cpu_stage (i, COLLECTD_CPU_STATE_NICE, (derive_t) cpuinfo[i][CP_NICE], now);
cpu_stage (i, COLLECTD_CPU_STATE_SYSTEM, (derive_t) cpuinfo[i][CP_SYS], now);
#elif defined(HAVE_PERFSTAT) /* {{{ */
perfstat_id_t id;
- int i, cpus;
+ int cpus;
numcpu = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0);
if(numcpu == -1)
return (-1);
}
- for (i = 0; i < cpus; i++)
+ for (int i = 0; i < cpus; i++)
{
cpu_stage (i, COLLECTD_CPU_STATE_IDLE, (derive_t) perfcpu[i].idle, now);
cpu_stage (i, COLLECTD_CPU_STATE_SYSTEM, (derive_t) perfcpu[i].sys, now);
{
int status;
unsigned long long val;
- int i = 0;
FILE *fp;
char filename[256];
char buffer[16];
- for (i = 0; i < num_cpu; i++)
+ for (int i = 0; i < num_cpu; i++)
{
status = ssnprintf (filename, sizeof (filename),
"/sys/devices/system/cpu/cpu%d/cpufreq/"
{
int offset;
int status;
- size_t i;
gauge_t *rates = NULL;
assert (0 == strcmp (ds->type, vl->type));
return (-1);
offset = status;
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if ((ds->ds[i].type != DS_TYPE_COUNTER)
&& (ds->ds[i].type != DS_TYPE_GAUGE)
static int csv_create_file (const char *filename, const data_set_t *ds)
{
FILE *csv;
- size_t i;
if (check_create_dir (filename))
return (-1);
}
fprintf (csv, "epoch");
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
fprintf (csv, ",%s", ds->ds[i].name);
fprintf (csv, "\n");
if (use_stdio)
{
- size_t i;
-
escape_string (filename, sizeof (filename));
/* Replace commas by colons for PUTVAL compatible output. */
- for (i = 0; i < sizeof (values); i++)
+ for (size_t i = 0; i < sizeof (values); i++)
{
if (values[i] == 0)
break;
{
web_match_t *match;
int status;
- int i;
if (ci->values_num != 0)
{
}
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
web_page_t *page;
int status;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
/* Process all children */
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
int success;
int errors;
int status;
- int i;
success = 0;
errors = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int cc_read_page (web_page_t *wp) /* {{{ */
{
- web_match_t *wm;
int status;
cdtime_t start = 0;
}
}
- for (wm = wp->matches; wm != NULL; wm = wm->next)
+ for (web_match_t *wm = wp->matches; wm != NULL; wm = wm->next)
{
cu_match_value_t *mv;
static int cc_read (void) /* {{{ */
{
- web_page_t *wp;
-
- for (wp = pages_g; wp != NULL; wp = wp->next)
+ for (web_page_t *wp = pages_g; wp != NULL; wp = wp->next)
cc_read_page (wp);
return (0);
{
cj_key_t *key;
int status;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
}
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
cj_t *db;
int status = 0;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
}
/* Fill the `cj_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
int success;
int errors;
int status;
- int i;
success = 0;
errors = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (key->instance == NULL)
{
- int i, len = 0;
- for (i = 0; i < db->depth; i++)
+ int len = 0;
+ for (int i = 0; i < db->depth; i++)
len += ssnprintf(vl.type_instance+len, sizeof(vl.type_instance)-len,
i ? "-%s" : "%s", db->state[i+1].name);
}
static void cx_free (void *arg) /* {{{ */
{
cx_t *db;
- size_t i;
DEBUG ("curl_xml plugin: cx_free (arg = %p);", arg);
curl_slist_free_all (db->headers);
curl_stats_destroy (db->stats);
- for (i = 0; i < db->namespaces_num; i++)
+ for (size_t i = 0; i < db->namespaces_num; i++)
{
sfree (db->namespaces[i].prefix);
sfree (db->namespaces[i].url);
{
value_t values[xpath->values_len];
int status;
- size_t i;
assert (xpath->values_len > 0);
assert (xpath->values_len == vl->values_len);
assert (xpath->values_len == ds->ds_num);
vl->values = values;
- for (i = 0; i < xpath->values_len; i++)
+ for (size_t i = 0; i < xpath->values_len; i++)
{
status = cx_handle_single_value_xpath (xpath_ctx, xpath, ds, vl, i);
if (status != 0)
char *base_xpath, cx_xpath_t *xpath)
{
int total_nodes;
- int i;
xmlXPathObjectPtr base_node_obj = NULL;
xmlNodeSetPtr base_nodes = NULL;
if (plugin_instance != NULL)
sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
- for (i = 0; i < total_nodes; i++)
+ for (int i = 0; i < total_nodes; i++)
{
int status;
int status;
xmlDocPtr doc;
xmlXPathContextPtr xpath_ctx;
- size_t i;
/* Load the XML */
doc = xmlParseDoc(xml);
return (-1);
}
- for (i = 0; i < db->namespaces_num; i++)
+ for (size_t i = 0; i < db->namespaces_num; i++)
{
cx_namespace_t const *ns = db->namespaces + i;
status = xmlXPathRegisterNs (xpath_ctx,
static int cx_config_add_values (const char *name, cx_xpath_t *xpath, /* {{{ */
oconfig_item_t *ci)
{
- int i;
-
if (ci->values_num < 1)
{
WARNING ("curl_xml plugin: `ValuesFrom' needs at least one argument.");
return (-1);
}
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
if (ci->values[i].type != OCONFIG_TYPE_STRING)
{
WARNING ("curl_xml plugin: `ValuesFrom' needs only string argument.");
xpath->values_len = (size_t) ci->values_num;
/* populate cx_values_t structure */
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
xpath->values[i].path_len = sizeof (ci->values[i].value.string);
sstrncpy (xpath->values[i].path, ci->values[i].value.string, sizeof (xpath->values[i].path));
char *name;
llentry_t *le;
int status;
- int i;
xpath = calloc (1, sizeof (*xpath));
if (xpath == NULL)
}
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
cx_t *db;
int status = 0;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
}
/* Fill the `cx_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
int success;
int errors;
int status;
- int i;
success = 0;
errors = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
const char *str;
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
str = global_option_get ("Hostname");
return (-1);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
if (ai_ptr->ai_canonname == NULL)
continue;
size_t avail;
char *ptr;
size_t sep_len;
- size_t i;
if ((buffer_size < 1) || (fields_num == 0))
return (-1);
if (sep != NULL)
sep_len = strlen (sep);
- for (i = 0; i < fields_num; i++)
+ for (size_t i = 0; i < fields_num; i++)
{
size_t field_len;
int escape_string (char *buffer, size_t buffer_size)
{
char *temp;
- size_t i;
size_t j;
/* Check if we need to escape at all first */
temp[0] = '"';
j = 1;
- for (i = 0; i < buffer_size; i++)
+ for (size_t i = 0; i < buffer_size; i++)
{
if (buffer[i] == 0)
{
int strunescape (char *buf, size_t buf_len)
{
- size_t i;
-
- for (i = 0; (i < buf_len) && (buf[i] != '\0'); ++i)
+ for (size_t i = 0; (i < buf_len) && (buf[i] != '\0'); ++i)
{
if (buf[i] != '\\')
continue;
int escape_slashes (char *buffer, size_t buffer_size)
{
size_t buffer_len;
- size_t i;
buffer_len = strlen (buffer);
buffer_len--;
}
- for (i = 0; i < buffer_len; i++)
+ for (size_t i = 0; i < buffer_len; i++)
{
if (buffer[i] == '/')
buffer[i] = '_';
void replace_special (char *buffer, size_t buffer_size)
{
- size_t i;
-
- for (i = 0; i < buffer_size; i++)
+ for (size_t i = 0; i < buffer_size; i++)
{
if (buffer[i] == 0)
return;
int last_is_file = 1;
int path_is_absolute = 0;
size_t len;
- int i;
/*
* Sanity checks first
/*
* For each component, do..
*/
- for (i = 0; i < (fields_num - last_is_file); i++)
+ for (int i = 0; i < (fields_num - last_is_file); i++)
{
/*
* Do not create directories that start with a dot. This
{
size_t offset = 0;
int status;
- size_t i;
gauge_t *rates = NULL;
assert (0 == strcmp (ds->type, vl->type));
BUFFER_ADD ("%.3f", CDTIME_T_TO_DOUBLE (vl->time));
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if (ds->ds[i].type == DS_TYPE_GAUGE)
BUFFER_ADD (":"GAUGE_FORMAT, vl->values[i].gauge);
int service_name_to_port_number (const char *service_name)
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
int service_number;
}
service_number = -1;
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
if (ai_ptr->ai_family == AF_INET)
{
void strarray_free (char **array, size_t array_len) /* {{{ */
{
- size_t i;
-
- for (i = 0; i < array_len; i++)
+ for (size_t i = 0; i < array_len; i++)
sfree (array[i]);
sfree (array);
} /* }}} void strarray_free */
{"trailing/slash/", "trailing_slash_"},
{"foo//bar", "foo__bar"},
};
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
char buffer[32];
strncpy (buffer, cases[i].str, sizeof (buffer));
{"012345 78901234", "\"012345 789012\""},
{"012345 78901\"34", "\"012345 78901\""},
};
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
char buffer[16];
strncpy (buffer, cases[i].str, sizeof (buffer));
{"T:42.0", -1, NAN},
};
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
{
data_source_t dsrc = {
.name = "value",
/* 64bit wrap-around. */
{30, 40, DS_TYPE_COUNTER, {.counter = 18446744073709551558ULL}, {.counter = 42}, 10.0},
};
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
value_to_rate_state_t state = { cases[i].v0, TIME_T_TO_CDTIME_T (cases[i].t0) };
gauge_t got;
char *key;
char *value;
int ret;
- int i;
+ int i = 0;
if (orig_key == NULL)
return (EINVAL);
static int dispatch_value_typesdb (oconfig_item_t *ci)
{
- int i = 0;
-
assert (strcasecmp (ci->key, "TypesDB") == 0);
cf_default_typesdb = 0;
return (-1);
}
- for (i = 0; i < ci->values_num; ++i)
+ for (int i = 0; i < ci->values_num; ++i)
{
if (OCONFIG_TYPE_STRING != ci->values[i].type) {
WARNING ("configfile: TypesDB: Skipping %i. argument which "
static int dispatch_loadplugin (oconfig_item_t *ci)
{
- int i;
const char *name;
unsigned int flags = 0;
plugin_ctx_t ctx = { 0 };
ctx.flush_interval = 0;
ctx.flush_timeout = 0;
- for (i = 0; i < ci->children_num; ++i)
+ for (int i = 0; i < ci->children_num; ++i)
{
oconfig_item_t *child = ci->children + i;
char buffer[4096];
char *buffer_ptr;
int buffer_free;
- int i;
buffer_ptr = buffer;
buffer_free = sizeof (buffer);
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
int status = -1;
static int dispatch_value (oconfig_item_t *ci)
{
int ret = 0;
- int i;
- for (i = 0; i < cf_value_map_num; i++)
+ for (int i = 0; i < cf_value_map_num; i++)
if (strcasecmp (cf_value_map[i].key, ci->key) == 0)
{
ret = cf_value_map[i].func (ci);
break;
}
- for (i = 0; i < cf_global_options_num; i++)
+ for (int i = 0; i < cf_global_options_num; i++)
if (strcasecmp (cf_global_options[i].key, ci->key) == 0)
{
ret = dispatch_global_option (ci);
static int dispatch_block_plugin (oconfig_item_t *ci)
{
- int i;
const char *name;
- cf_complex_callback_t *cb;
-
if (strcasecmp (ci->key, "Plugin") != 0)
return (-1);
if (ci->values_num < 1)
}
/* Check for a complex callback first */
- for (cb = complex_callback_head; cb != NULL; cb = cb->next)
+ for (cf_complex_callback_t *cb = complex_callback_head; cb != NULL; cb = cb->next)
{
if (strcasecmp (name, cb->type) == 0)
{
}
/* Hm, no complex plugin found. Dispatch the values one by one */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
if (ci->children[i].children == NULL)
dispatch_value_plugin (name, ci->children + i);
int offset)
{
oconfig_item_t *temp;
- int i;
assert (offset >= 0);
assert (dst->children_num > offset);
/* Free the memory used by the replaced child. Usually that's the
* `Include "blah"' statement. */
temp = dst->children + offset;
- for (i = 0; i < temp->values_num; i++)
+ for (int i = 0; i < temp->values_num; i++)
{
if (temp->values[i].type == OCONFIG_TYPE_STRING)
{
static int cf_include_all (oconfig_item_t *root, int depth)
{
- int i;
-
- for (i = 0; i < root->children_num; i++)
+ for (int i = 0; i < root->children_num; i++)
{
oconfig_item_t *new;
oconfig_item_t *old;
char *pattern = NULL;
- int j;
-
if (strcasecmp (root->children[i].key, "Include") != 0)
continue;
continue;
}
- for (j = 0; j < old->children_num; ++j)
+ for (int j = 0; j < old->children_num; ++j)
{
oconfig_item_t *child = old->children + j;
char **filenames = NULL;
int filenames_num = 0;
int status;
- int i;
assert (depth < CF_MAX_DEPTH);
" name is too long.",
dir, de->d_name);
closedir (dh);
- for (i = 0; i < filenames_num; ++i)
+ for (int i = 0; i < filenames_num; ++i)
free (filenames[i]);
free (filenames);
free (root);
if (tmp == NULL) {
ERROR ("configfile: realloc failed.");
closedir (dh);
- for (i = 0; i < filenames_num - 1; ++i)
+ for (int i = 0; i < filenames_num - 1; ++i)
free (filenames[i]);
free (filenames);
free (root);
qsort ((void *) filenames, filenames_num, sizeof (*filenames),
cf_compare_string);
- for (i = 0; i < filenames_num; ++i)
+ for (int i = 0; i < filenames_num; ++i)
{
oconfig_item_t *temp;
char *name = filenames[i];
int status;
const char *path_ptr;
wordexp_t we;
- size_t i;
if (depth >= CF_MAX_DEPTH)
{
qsort ((void *) we.we_wordv, we.we_wordc, sizeof (*we.we_wordv),
cf_compare_string);
- for (i = 0; i < we.we_wordc; i++)
+ for (size_t i = 0; i < we.we_wordc; i++)
{
oconfig_item_t *temp;
struct stat statbuf;
int global_option_set (const char *option, const char *value, _Bool from_cli)
{
int i;
-
DEBUG ("option = %s; value = %s;", option, value);
for (i = 0; i < cf_global_options_num; i++)
const char *global_option_get (const char *option)
{
int i;
-
for (i = 0; i < cf_global_options_num; i++)
if (strcasecmp (cf_global_options[i].key, option) == 0)
break;
void cf_unregister (const char *type)
{
- cf_callback_t *this, *prev;
-
- for (prev = NULL, this = first_callback;
+ for (cf_callback_t *prev = NULL, *this = first_callback;
this != NULL;
prev = this, this = this->next)
if (strcasecmp (this->type, type) == 0)
void cf_unregister_complex (const char *type)
{
- cf_complex_callback_t *this, *prev;
-
- for (prev = NULL, this = complex_callback_head;
+ for (cf_complex_callback_t *prev = NULL, *this = complex_callback_head;
this != NULL;
prev = this, this = this->next)
if (strcasecmp (this->type, type) == 0)
int cf_read (const char *filename)
{
oconfig_item_t *conf;
- int i;
int ret = 0;
conf = cf_read_generic (filename, /* pattern = */ NULL, /* depth = */ 0);
return (-1);
}
- for (i = 0; i < conf->children_num; i++)
+ for (int i = 0; i < conf->children_num; i++)
{
if (conf->children[i].children == NULL)
{
fc_rule_t *rule;
char rule_name[2*DATA_MAX_NAME_LEN] = "Unnamed rule";
int status = 0;
- int i;
if (ci->values_num > 1)
{
ci->values[0].value.string);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
{
fc_chain_t *chain = NULL;
int status = 0;
- int i;
int new_chain = 1;
if ((ci->values_num != 1)
sstrncpy (chain->name, ci->values[0].value.string, sizeof (chain->name));
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int fc_bit_write_create (const oconfig_item_t *ci, /* {{{ */
void **user_data)
{
- int i;
-
fc_writer_t *plugin_list = NULL;
size_t plugin_list_len = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
fc_writer_t *temp;
- int j;
if (strcasecmp ("Plugin", child->key) != 0)
{
continue;
}
- for (j = 0; j < child->values_num; j++)
+ for (int j = 0; j < child->values_num; j++)
{
char *plugin;
static int fc_bit_write_destroy (void **user_data) /* {{{ */
{
fc_writer_t *plugin_list;
- size_t i;
if ((user_data == NULL) || (*user_data == NULL))
return (0);
plugin_list = *user_data;
- for (i = 0; plugin_list[i].plugin != NULL; i++)
+ for (size_t i = 0; plugin_list[i].plugin != NULL; i++)
free (plugin_list[i].plugin);
free (plugin_list);
}
else
{
- size_t i;
-
- for (i = 0; plugin_list[i].plugin != NULL; i++)
+ for (size_t i = 0; plugin_list[i].plugin != NULL; i++)
{
status = plugin_write (plugin_list[i].plugin, ds, vl);
if (status != 0)
fc_chain_t *fc_chain_get_by_name (const char *chain_name) /* {{{ */
{
- fc_chain_t *chain;
-
if (chain_name == NULL)
return (NULL);
- for (chain = chain_list_head; chain != NULL; chain = chain->next)
+ for (fc_chain_t *chain = chain_list_head; chain != NULL; chain = chain->next)
if (strcasecmp (chain_name, chain->name) == 0)
return (chain);
int fc_process_chain (const data_set_t *ds, value_list_t *vl, /* {{{ */
fc_chain_t *chain)
{
- fc_rule_t *rule;
fc_target_t *target;
int status = FC_TARGET_CONTINUE;
DEBUG ("fc_process_chain (chain = %s);", chain->name);
- for (rule = chain->rules; rule != NULL; rule = rule->next)
+ for (fc_rule_t *rule = chain->rules; rule != NULL; rule = rule->next)
{
fc_match_t *match;
status = FC_TARGET_CONTINUE;
int meta_data_clone_merge (meta_data_t **dest, meta_data_t *orig) /* {{{ */
{
- meta_entry_t *e;
-
if (orig == NULL)
return (0);
}
pthread_mutex_lock (&orig->lock);
- for (e=orig->head; e != NULL; e = e->next)
+ for (meta_entry_t *e=orig->head; e != NULL; e = e->next)
{
md_entry_insert_clone((*dest), e);
}
int meta_data_exists (meta_data_t *md, const char *key) /* {{{ */
{
- meta_entry_t *e;
-
if ((md == NULL) || (key == NULL))
return (-EINVAL);
pthread_mutex_lock (&md->lock);
- for (e = md->head; e != NULL; e = e->next)
+ for (meta_entry_t *e = md->head; e != NULL; e = e->next)
{
if (strcasecmp (key, e->key) == 0)
{
int meta_data_type (meta_data_t *md, const char *key) /* {{{ */
{
- meta_entry_t *e;
-
if ((md == NULL) || (key == NULL))
return -EINVAL;
pthread_mutex_lock (&md->lock);
- for (e = md->head; e != NULL; e = e->next)
+ for (meta_entry_t *e = md->head; e != NULL; e = e->next)
{
if (strcasecmp (key, e->key) == 0)
{
int meta_data_toc (meta_data_t *md, char ***toc) /* {{{ */
{
int i = 0, count = 0;
- meta_entry_t *e;
if ((md == NULL) || (toc == NULL))
return -EINVAL;
pthread_mutex_lock (&md->lock);
- for (e = md->head; e != NULL; e = e->next)
+ for (meta_entry_t *e = md->head; e != NULL; e = e->next)
++count;
if (count == 0)
}
*toc = calloc(count, sizeof(**toc));
- for (e = md->head; e != NULL; e = e->next)
+ for (meta_entry_t *e = md->head; e != NULL; e = e->next)
(*toc)[i++] = strdup(e->key);
pthread_mutex_unlock (&md->lock);
{
char *str;
int len;
- llentry_t *le;
int i;
+ llentry_t *le;
int n;
char **keys;
static void start_read_threads (int num)
{
- int i;
-
if (read_threads != NULL)
return;
}
read_threads_num = 0;
- for (i = 0; i < num; i++)
+ for (int i = 0; i < num; i++)
{
if (pthread_create (read_threads + read_threads_num, NULL,
plugin_read_thread, NULL) == 0)
static void stop_read_threads (void)
{
- int i;
-
if (read_threads == NULL)
return;
pthread_cond_broadcast (&read_cond);
pthread_mutex_unlock (&read_lock);
- for (i = 0; i < read_threads_num; i++)
+ for (int i = 0; i < read_threads_num; i++)
{
if (pthread_join (read_threads[i], NULL) != 0)
{
static void start_write_threads (size_t num) /* {{{ */
{
- size_t i;
-
if (write_threads != NULL)
return;
}
write_threads_num = 0;
- for (i = 0; i < num; i++)
+ for (size_t i = 0; i < num; i++)
{
int status;
int plugin_register_data_set (const data_set_t *ds)
{
data_set_t *ds_copy;
- size_t i;
if ((data_sets != NULL)
&& (c_avl_get (data_sets, ds->type, NULL) == 0))
return (-1);
}
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
memcpy (ds_copy->ds + i, ds->ds + i, sizeof (data_source_t));
return (c_avl_insert (data_sets, (void *) ds_copy->type, (void *) ds_copy));
int plugin_notification_meta_copy (notification_t *dst,
const notification_t *src)
{
- notification_meta_t *meta;
-
assert (dst != NULL);
assert (src != NULL);
assert (dst != src);
assert ((src->meta == NULL) || (src->meta != dst->meta));
- for (meta = src->meta; meta != NULL; meta = meta->next)
+ for (notification_meta_t *meta = src->meta; meta != NULL; meta = meta->next)
{
if (meta->type == NM_TYPE_STRING)
plugin_notification_meta_add_string (dst, meta->name,
char *fields[64];
size_t fields_num;
data_set_t *ds;
- size_t i;
fields_num = strsplit (buf, fields, 64);
if (fields_num < 2)
return;
}
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
if (parse_ds (ds->ds + i, fields[i + 1], strlen (fields[i + 1])) != 0)
{
ERROR ("types_list: parse_line: Cannot parse data source #%zu "
};
c_avl_tree_t *t;
- size_t i;
RESET_COUNTS ();
CHECK_NOT_NULL (t = c_avl_create (compare_callback));
/* insert */
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
{
char *key;
char *value;
}
/* Key already exists. */
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
EXPECT_EQ_INT (1, c_avl_insert (t, cases[i].key, cases[i].value));
/* get */
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++)
{
char *value_ret = NULL;
}
/* remove half */
- for (i = 0; i < STATIC_ARRAY_SIZE (cases) / 2; i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases) / 2; i++)
{
char *key = NULL;
char *value = NULL;
}
/* pick the other half */
- for (i = STATIC_ARRAY_SIZE (cases) / 2; i < STATIC_ARRAY_SIZE (cases); i++)
+ for (size_t i = STATIC_ARRAY_SIZE (cases) / 2; i < STATIC_ARRAY_SIZE (cases); i++)
{
char *key = NULL;
char *value = NULL;
static void uc_check_range (const data_set_t *ds, cache_entry_t *ce)
{
- size_t i;
-
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if (isnan (ce->values_gauge[i]))
continue;
{
char *key_copy;
cache_entry_t *ce;
- size_t i;
/* `cache_lock' has been locked by `uc_update' */
sstrncpy (ce->name, key, sizeof (ce->name));
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
switch (ds->ds[i].type)
{
c_avl_iterator_t *iter;
int status;
- int i;
pthread_mutex_lock (&cache_lock);
* including plugin specific meta data, rates, history, …. This must be done
* without holding the lock, otherwise we will run into a deadlock if a
* plugin calls the cache interface. */
- for (i = 0; i < keys_len; i++)
+ for (int i = 0; i < keys_len; i++)
{
value_list_t vl = VALUE_LIST_INIT;
* the timestamp again, so in theory it is possible we remove a value after
* it is updated here. */
pthread_mutex_lock (&cache_lock);
- for (i = 0; i < keys_len; i++)
+ for (int i = 0; i < keys_len; i++)
{
key = NULL;
ce = NULL;
char name[6 * DATA_MAX_NAME_LEN];
cache_entry_t *ce = NULL;
int status;
- size_t i;
if (FORMAT_VL (name, sizeof (name), vl) != 0)
{
return (-1);
}
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
switch (ds->ds[i].type)
{
if (ce->history != NULL)
{
assert (ce->history_index < ce->history_length);
- for (i = 0; i < ce->values_num; i++)
+ for (size_t i = 0; i < ce->values_num; i++)
{
size_t hist_idx = (ce->values_num * ce->history_index) + i;
ce->history[hist_idx] = ce->values_gauge[i];
if (status != 0)
{
- size_t i;
-
- for (i = 0; i < number; i++)
+ for (size_t i = 0; i < number; i++)
{
sfree (names[i]);
}
gauge_t *ret_history, size_t num_steps, size_t num_ds)
{
cache_entry_t *ce = NULL;
- size_t i;
int status = 0;
pthread_mutex_lock (&cache_lock);
return (-ENOMEM);
}
- for (i = ce->history_length * ce->values_num;
+ for (size_t i = ce->history_length * ce->values_num;
i < (num_steps * ce->values_num);
i++)
tmp[i] = NAN;
} /* if (ce->history_length < num_steps) */
/* Copy the values to the output buffer. */
- for (i = 0; i < num_steps; i++)
+ for (size_t i = 0; i < num_steps; i++)
{
size_t src_index;
size_t dst_index;
int uc_iterator_get_values (uc_iter_t *iter, value_t **ret_values, size_t *ret_num)
{
- size_t i;
-
if ((iter == NULL) || (iter->entry == NULL)
|| (ret_values == NULL) || (ret_num == NULL))
return (-1);
*ret_values = calloc (iter->entry->values_num, sizeof(*iter->entry->values_raw));
if (*ret_values == NULL)
return (-1);
- for (i = 0; i < iter->entry->values_num; ++i)
+ for (size_t i = 0; i < iter->entry->values_num; ++i)
*ret_values[i] = iter->entry->values_raw[i];
*ret_num = iter->entry->values_num;
DEF_TEST(simple)
{
int values[] = { 9, 5, 6, 1, 3, 4, 0, 8, 2, 7 };
- int i;
c_heap_t *h;
CHECK_NOT_NULL(h = c_heap_create (compare));
- for (i = 0; i < 10; i++)
+ for (int i = 0; i < 10; i++)
CHECK_ZERO(c_heap_insert (h, &values[i]));
- for (i = 0; i < 5; i++)
+ for (int i = 0; i < 5; i++)
{
int *ret = NULL;
CHECK_NOT_NULL(ret = c_heap_get_root(h));
CHECK_ZERO(c_heap_insert (h, &values[4] /* = 3 */));
CHECK_ZERO(c_heap_insert (h, &values[5] /* = 4 */));
- for (i = 0; i < 10; i++)
+ for (int i = 0; i < 10; i++)
{
int *ret = NULL;
CHECK_NOT_NULL(ret = c_heap_get_root(h));
*/
int ignorelist_match (ignorelist_t *il, const char *entry)
{
- ignorelist_item_t *traverse;
-
/* if no entries, collect all */
if ((il == NULL) || (il->head == NULL))
return (0);
return (0);
/* traverse list and check entries */
- for (traverse = il->head; traverse != NULL; traverse = traverse->next)
+ for (ignorelist_item_t *traverse = il->head; traverse != NULL; traverse = traverse->next)
{
#if HAVE_REGEX_H
if (traverse->rmatch != NULL)
regmatch_t re_match[32];
char *matches[32] = { 0 };
size_t matches_num;
- size_t i;
if ((obj == NULL) || (str == NULL))
return (-1);
}
}
- for (i = 0; i < matches_num; i++)
+ for (size_t i = 0; i < matches_num; i++)
{
sfree (matches[i]);
}
{"foo bar", 4, 3, "_", NULL}, /* off1 > off2 */
{"foo bar", 3, 4, NULL, NULL}, /* no replacement */
};
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
char buffer[16] = "!!!!!!!!!!!!!!!";
if (cases[i].want == NULL) {
{"foo bar", "oo", "oo", "foo bar"},
{"sixteen chars", "chars", "characters", "sixteen charact"},
};
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
char buffer[16];
if (cases[i].want == NULL) {
int __attribute__((unused)) buflen)
{
cu_tail_match_t *obj = (cu_tail_match_t *) data;
- size_t i;
- for (i = 0; i < obj->matches_num; i++)
+ for (size_t i = 0; i < obj->matches_num; i++)
match_apply (obj->matches[i].match, buf);
return (0);
void tail_match_destroy (cu_tail_match_t *obj)
{
- size_t i;
-
if (obj == NULL)
return;
obj->tail = NULL;
}
- for (i = 0; i < obj->matches_num; i++)
+ for (size_t i = 0; i < obj->matches_num; i++)
{
cu_tail_match_match_t *match = obj->matches + i;
if (match->match != NULL)
{
char buffer[4096];
int status;
- size_t i;
status = cu_tail_read (obj->tail, buffer, sizeof (buffer), tail_callback,
(void *) obj);
return (status);
}
- for (i = 0; i < obj->matches_num; i++)
+ for (size_t i = 0; i < obj->matches_num; i++)
{
cu_tail_match_match_t *lt_match = obj->matches + i;
// 1546167986577716567 / 2^30 = 1439981150.0475896215...
{1546167986577716567ULL, 1439981150.048, 1439981150, 1439981150048ULL, {1439981150, 47590}, {1439981150, 47589622}},
};
- size_t i;
- for (i = 0; i < (sizeof (cases) / sizeof (cases[0])); i++) {
+ for (size_t i = 0; i < (sizeof (cases) / sizeof (cases[0])); i++) {
struct timeval tv;
struct timespec ts;
// 1439981880053705608 * 2^30 / 10^9 = 1546168770415815077.4
{1439981880053705608ULL, 1546168770415815077ULL},
};
- size_t i;
- for (i = 0; i < (sizeof (cases) / sizeof (cases[0])); i++) {
+ for (size_t i = 0; i < (sizeof (cases) / sizeof (cases[0])); i++) {
EXPECT_EQ_UINT64 (cases[i].want, NS_TO_CDTIME_T (cases[i].ns));
}
static void cdbi_database_free (cdbi_database_t *db) /* {{{ */
{
- size_t i;
-
if (db == NULL)
return;
sfree (db->name);
sfree (db->driver);
- for (i = 0; i < db->driver_options_num; i++)
+ for (size_t i = 0; i < db->driver_options_num; i++)
{
sfree (db->driver_options[i].key);
if (!db->driver_options[i].is_numeric)
sfree (db->driver_options);
if (db->q_prep_areas)
- for (i = 0; i < db->queries_num; ++i)
+ for (size_t i = 0; i < db->queries_num; ++i)
udb_query_delete_preparation_area (db->q_prep_areas[i]);
free (db->q_prep_areas);
{
cdbi_database_t *db;
int status;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
}
/* Fill the `cdbi_database_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
while ((status == 0) && (db->queries_num > 0))
{
- size_t j;
-
db->q_prep_areas = calloc (db->queries_num, sizeof (*db->q_prep_areas));
if (db->q_prep_areas == NULL)
{
break;
}
- for (j = 0; j < db->queries_num; ++j)
+ for (size_t i = 0; i < db->queries_num; ++i)
{
- db->q_prep_areas[j]
- = udb_query_allocate_preparation_area (db->queries[j]);
+ db->q_prep_areas[i]
+ = udb_query_allocate_preparation_area (db->queries[i]);
- if (db->q_prep_areas[j] == NULL)
+ if (db->q_prep_areas[i] == NULL)
{
WARNING ("dbi plugin: udb_query_allocate_preparation_area failed");
status = -1;
static int cdbi_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Query", child->key) == 0)
char **column_names;
char **column_values;
int status;
- size_t i;
/* Macro that cleans up dynamically allocated memory and returns the
* specified status. */
ERROR ("dbi plugin: calloc failed.");
BAIL_OUT (-1);
}
- for (i = 1; i < column_num; i++)
+ for (size_t i = 1; i < column_num; i++)
column_names[i] = column_names[i - 1] + DATA_MAX_NAME_LEN;
column_values = calloc (column_num, sizeof (*column_values));
ERROR ("dbi plugin: calloc failed.");
BAIL_OUT (-1);
}
- for (i = 1; i < column_num; i++)
+ for (size_t i = 1; i < column_num; i++)
column_values[i] = column_values[i - 1] + DATA_MAX_NAME_LEN;
/* }}} */
/* Copy the field names to `column_names' */
- for (i = 0; i < column_num; i++) /* {{{ */
+ for (size_t i = 0; i < column_num; i++) /* {{{ */
{
const char *column_name;
{
status = 0;
/* Copy the value of the columns to `column_values' */
- for (i = 0; i < column_num; i++) /* {{{ */
+ for (size_t i = 0; i < column_num; i++) /* {{{ */
{
status = cdbi_result_get_field (res, (unsigned int) (i + 1),
column_values[i], DATA_MAX_NAME_LEN);
{
dbi_driver driver;
dbi_conn connection;
- size_t i;
int status;
if (db->connection != NULL)
* encountered, it will get a list of options understood by the driver and
* report that as `INFO'. This way, users hopefully don't have too much
* trouble finding out how to configure the plugin correctly.. */
- for (i = 0; i < db->driver_options_num; i++)
+ for (size_t i = 0; i < db->driver_options_num; i++)
{
if (db->driver_options[i].is_numeric)
{
if (status != 0)
{
- char const *opt;
-
INFO ("dbi plugin: This is a list of all options understood "
"by the `%s' driver:", db->driver);
- for (opt = dbi_conn_get_option_list (connection, NULL);
+ for (const char *opt = dbi_conn_get_option_list (connection, NULL);
opt != NULL;
opt = dbi_conn_get_option_list (connection, opt))
{
static int cdbi_read_database (user_data_t *ud) /* {{{ */
{
cdbi_database_t *db = (cdbi_database_t *) ud->data;
- size_t i;
int success;
int status;
/* TODO: Complain if `db_version == 0' */
success = 0;
- for (i = 0; i < db->queries_num; i++)
+ for (size_t i = 0; i < db->queries_num; i++)
{
/* Check if we know the database's version and if so, if this query applies
* to that version. */
static int cdbi_shutdown (void) /* {{{ */
{
- size_t i;
-
- for (i = 0; i < databases_num; i++)
+ for (size_t i = 0; i < databases_num; i++)
{
if (databases[i]->connection != NULL)
{
#endif
/* struct STATANYFS statbuf; */
cu_mount_t *mnt_list;
- cu_mount_t *mnt_ptr;
mnt_list = NULL;
if (cu_mount_getlist (&mnt_list) == NULL)
return (-1);
}
- for (mnt_ptr = mnt_list; mnt_ptr != NULL; mnt_ptr = mnt_ptr->next)
+ for (cu_mount_t *mnt_ptr = mnt_list; mnt_ptr != NULL; mnt_ptr = mnt_ptr->next)
{
unsigned long long blocksize;
char disk_name[256];
sstrncpy (disk_name, "root", sizeof (disk_name));
else
{
- int i, len;
+ int len;
sstrncpy (disk_name, mnt_ptr->dir + 1, sizeof (disk_name));
len = strlen (disk_name);
- for (i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
if (disk_name[i] == '/')
disk_name[i] = '-';
}
# error "kstat_io_t does not have the required members"
# endif
static kstat_io_t kio;
- int i;
if (kc == NULL)
return (-1);
- for (i = 0; i < numdisk; i++)
+ for (int i = 0; i < numdisk; i++)
{
if (kstat_read (kc, ksp[i], &kio) == -1)
continue;
# else
int disks;
#endif
- int counter;
char name[DATA_MAX_NAME_LEN];
if ((ds = sg_get_disk_io_stats(&disks)) == NULL)
return (0);
- for (counter=0; counter < disks; counter++) {
+ for (int counter = 0; counter < disks; counter++) {
strncpy(name, ds->disk_name, sizeof(name));
name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */
derive_t write_ops;
perfstat_id_t firstpath;
int rnumdisk;
- int i;
if ((numdisk = perfstat_disk(NULL, NULL, sizeof(perfstat_disk_t), 0)) < 0)
{
return (-1);
}
- for (i = 0; i < rnumdisk; i++)
+ for (int i = 0; i < rnumdisk; i++)
{
if (ignorelist_match (ignorelist, stat_disk[i].name) != 0)
continue;
unsigned int keys[T_MAX];
unsigned int values[T_MAX];
int len;
- int i;
counter_list_t *ptr;
}
pthread_mutex_unlock (&qtype_mutex);
- for (i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
{
DEBUG ("dns plugin: qtype = %u; counter = %u;", keys[i], values[i]);
submit_derive ("dns_qtype", qtype_str (keys[i]), values[i]);
}
pthread_mutex_unlock (&opcode_mutex);
- for (i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
{
DEBUG ("dns plugin: opcode = %u; counter = %u;", keys[i], values[i]);
submit_derive ("dns_opcode", opcode_str (keys[i]), values[i]);
}
pthread_mutex_unlock (&rcode_mutex);
- for (i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
{
DEBUG ("dns plugin: rcode = %u; counter = %u;", keys[i], values[i]);
submit_derive ("dns_rcode", rcode_str (keys[i]), values[i]);
char plugin_instance[DATA_MAX_NAME_LEN];
value_t values[fields_num];
value_list_t vl = VALUE_LIST_INIT;
- size_t i;
if (resource < 0)
{
ssnprintf (plugin_instance, sizeof (plugin_instance), "r%ld",
resource);
- for (i = 0; i < drbd_names_num; i++)
+ for (size_t i = 0; i < drbd_names_num; i++)
{
char *data;
/* skip non numeric wo */
sizeof (vl.plugin_instance));
sstrncpy (vl.type, "drbd_resource", sizeof (vl.type));
- for (i = 0; i < fields_num; i++)
+ for (size_t i = 0; i < fields_num; i++)
{
if (drbd_names[i] == NULL)
continue;
}
{ /* initialize collector threads */
- int i = 0;
-
pthread_attr_t ptattr;
conns.head = NULL;
collectors =
smalloc (max_conns * sizeof (*collectors));
- for (i = 0; i < max_conns; ++i) {
+ for (int i = 0; i < max_conns; ++i) {
collectors[i] = smalloc (sizeof (*collectors[i]));
collectors[i]->socket = NULL;
static int email_shutdown (void)
{
- int i = 0;
-
if (connector != ((pthread_t) 0)) {
pthread_kill (connector, SIGTERM);
connector = (pthread_t) 0;
available_collectors = 0;
if (collectors != NULL) {
- for (i = 0; i < max_conns; ++i) {
+ for (int i = 0; i < max_conns; ++i) {
if (collectors[i] == NULL)
continue;
* after they have been copied to l2. */
static void copy_type_list (type_list_t *l1, type_list_t *l2)
{
- type_t *ptr1;
- type_t *ptr2;
-
type_t *last = NULL;
- for (ptr1 = l1->head, ptr2 = l2->head; NULL != ptr1;
+ for (type_t *ptr1 = l1->head, *ptr2 = l2->head; NULL != ptr1;
ptr1 = ptr1->next, last = ptr2, ptr2 = ptr2->next) {
if (NULL == ptr2) {
ptr2 = smalloc (sizeof (*ptr2));
static int email_read (void)
{
- type_t *ptr;
-
double score_old;
int score_count_old;
pthread_mutex_unlock (&count_mutex);
- for (ptr = list_count_copy.head; NULL != ptr; ptr = ptr->next) {
+ for (type_t *ptr = list_count_copy.head; NULL != ptr; ptr = ptr->next) {
email_submit ("email_count", ptr->name, ptr->value);
}
pthread_mutex_unlock (&size_mutex);
- for (ptr = list_size_copy.head; NULL != ptr; ptr = ptr->next) {
+ for (type_t *ptr = list_size_copy.head; NULL != ptr; ptr = ptr->next) {
email_submit ("email_size", ptr->name, ptr->value);
}
pthread_mutex_unlock (&check_mutex);
- for (ptr = list_check_copy.head; NULL != ptr; ptr = ptr->next)
+ for (type_t *ptr = list_check_copy.head; NULL != ptr; ptr = ptr->next)
email_submit ("spam_check", ptr->name, ptr->value);
return (0);
static int ethstat_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
size_t n_stats;
size_t strings_size;
size_t stats_size;
- size_t i;
int status;
fd = socket(AF_INET, SOCK_DGRAM, /* protocol = */ 0);
return (-1);
}
- for (i = 0; i < n_stats; i++)
+ for (size_t i = 0; i < n_stats; i++)
{
char *stat_name;
static int ethstat_read(void)
{
- size_t i;
-
- for (i = 0; i < interfaces_num; i++)
+ for (size_t i = 0; i < interfaces_num; i++)
ethstat_read_interface (interfaces[i]);
return 0;
static int exec_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if ((strcasecmp ("Exec", child->key) == 0)
else if (pid == 0)
{
int fd_num;
- int fd;
/* Close all file descriptors but the pipe end we need. */
fd_num = getdtablesize ();
- for (fd = 0; fd < fd_num; fd++)
+ for (int fd = 0; fd < fd_num; fd++)
{
if ((fd == fd_pipe_in[0])
|| (fd == fd_pipe_out[1])
{
program_list_t *pl = ((program_list_and_notification_t *) arg)->pl;
notification_t *n = &((program_list_and_notification_t *) arg)->n;
- notification_meta_t *meta;
int fd;
FILE *fh;
int pid;
if (strlen (n->type_instance) > 0)
fprintf (fh, "TypeInstance: %s\n", n->type_instance);
- for (meta = n->meta; meta != NULL; meta = meta->next)
+ for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next)
{
if (meta->type == NM_TYPE_STRING)
fprintf (fh, "%s: %s\n", meta->name, meta->nm_value.nm_string);
static int exec_read (void) /* {{{ */
{
- program_list_t *pl;
-
- for (pl = pl_head; pl != NULL; pl = pl->next)
+ for (program_list_t *pl = pl_head; pl != NULL; pl = pl->next)
{
pthread_t t;
pthread_attr_t attr;
static int exec_notification (const notification_t *n, /* {{{ */
user_data_t __attribute__((unused)) *user_data)
{
- program_list_t *pl;
program_list_and_notification_t *pln;
- for (pl = pl_head; pl != NULL; pl = pl->next)
+ for (program_list_t *pl = pl_head; pl != NULL; pl = pl->next)
{
pthread_t t;
pthread_attr_t attr;
{
fc_directory_conf_t *dir;
int status;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
dir->size = 0;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int fc_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Directory", child->key) == 0)
static int fc_read (void)
{
- size_t i;
-
- for (i = 0; i < directories_num; i++)
+ for (size_t i = 0; i < directories_num; i++)
fc_read_dir (directories[i]);
return (0);
char *lineptr;
char *fields[32];
int fields_num;
- int i;
/* Find the colon and replace it with a null byte */
lineptr = strchr (linebuffer, ':');
if (fields_num <= 0)
continue;
- for (i = 0; i < fields_num; i++)
+ for (int i = 0; i < fields_num; i++)
{
char *field_name;
char *field_value_str;
const char *node, const char *service, int listen)
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int ai_return;
socket_entry_t *sockets = NULL;
return (-1);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) /* {{{ */
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) /* {{{ */
{
socket_entry_t *tmp;
char buffer[BUFF_SIZE] = { 0 };
unsigned int buffer_size;
XDR xdr;
- size_t i;
msg.id = gmetadata_request;
msg.Ganglia_metadata_msg_u.grequest.metric_id.host = strdup (host);
host, name);
pthread_mutex_lock (&mc_send_sockets_lock);
- for (i = 0; i < mc_send_sockets_num; i++)
+ for (size_t i = 0; i < mc_send_sockets_num; i++)
{
ssize_t status = sendto (mc_send_sockets[i].fd, buffer, (size_t) buffer_size,
/* flags = */ 0,
{
socket_entry_t *mc_receive_socket_entries;
int status;
- size_t i;
mc_receive_socket_entries = NULL;
status = create_sockets (&mc_receive_socket_entries, &mc_receive_sockets_num,
if (mc_receive_sockets == NULL)
{
ERROR ("gmond plugin: calloc failed.");
- for (i = 0; i < mc_receive_sockets_num; i++)
+ for (size_t i = 0; i < mc_receive_sockets_num; i++)
close (mc_receive_socket_entries[i].fd);
free (mc_receive_socket_entries);
mc_receive_socket_entries = NULL;
return ((void *) -1);
}
- for (i = 0; i < mc_receive_sockets_num; i++)
+ for (size_t i = 0; i < mc_receive_sockets_num; i++)
{
mc_receive_sockets[i].fd = mc_receive_socket_entries[i].fd;
mc_receive_sockets[i].events = POLLIN | POLLPRI;
break;
}
- for (i = 0; i < mc_receive_sockets_num; i++)
+ for (size_t i = 0; i < mc_receive_sockets_num; i++)
{
if (mc_receive_sockets[i].revents != 0)
mc_handle_socket (mc_receive_sockets + i);
static int gmond_config_add_metric (oconfig_item_t *ci) /* {{{ */
{
metric_map_t *map;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
return (-1);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Type", child->key) == 0)
static int gmond_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("MCReceiveFrom", child->key) == 0)
static int gmond_shutdown (void) /* {{{ */
{
- size_t i;
-
mc_receive_thread_stop ();
pthread_mutex_lock (&mc_send_sockets_lock);
- for (i = 0; i < mc_send_sockets_num; i++)
+ for (size_t i = 0; i < mc_send_sockets_num; i++)
{
close (mc_send_sockets[i].fd);
mc_send_sockets[i].fd = -1;
const char *host;
const char *port;
- struct addrinfo *ai_list, *ai_ptr;
+ struct addrinfo *ai_list;
int ai_return;
host = hddtemp_host;
}
fd = -1;
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
/* create our socket descriptor */
fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
char *saveptr;
int num_fields;
int num_disks;
- int i;
/* get data from daemon */
if (hddtemp_query_daemon (buf, sizeof (buf)) < 0)
num_disks = num_fields / 4;
- for (i = 0; i < num_disks; i++)
+ for (int i = 0; i < num_disks; i++)
{
char *name;
double temperature;
{
#if HAVE_GETIFADDRS
struct ifaddrs *if_list;
- struct ifaddrs *if_ptr;
/* Darwin/Mac OS X and possible other *BSDs */
#if HAVE_STRUCT_IF_DATA
if (getifaddrs (&if_list) != 0)
return (-1);
- for (if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next)
+ for (struct ifaddrs *if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next)
{
if (if_ptr->ifa_addr != NULL && if_ptr->ifa_addr->sa_family == AF_LINK) {
if_data = (struct IFA_DATA *) if_ptr->ifa_data;
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
- int i;
derive_t rx;
derive_t tx;
char iname[DATA_MAX_NAME_LEN];
if (kc == NULL)
return (-1);
- for (i = 0; i < numif; i++)
+ for (int i = 0; i < numif; i++)
{
if (kstat_read (kc, ksp[i], NULL) == -1)
continue;
#elif defined(HAVE_LIBSTATGRAB)
sg_network_io_stats *ios;
- int i, num;
+ int num;
ios = sg_get_network_io_stats (&num);
- for (i = 0; i < num; i++) {
+ for (int i = 0; i < num; i++) {
if (!report_inactive && ios[i].rx == 0 && ios[i].tx == 0)
continue;
if_submit (ios[i].interface_name, "if_octets", ios[i].rx, ios[i].tx);
#elif defined(HAVE_PERFSTAT)
perfstat_id_t id;
- int i, ifs;
+ int ifs;
if ((nif = perfstat_netinterface(NULL, NULL, sizeof(perfstat_netinterface_t), 0)) < 0)
{
return (-1);
}
- for (i = 0; i < ifs; i++)
+ for (int i = 0; i < ifs; i++)
{
if (!report_inactive && ifstat[i].ipackets == 0 && ifstat[i].opackets == 0)
continue;
ipcinfo_sem_t *ipcinfo_sem;
unsigned short sem_nsems=0;
unsigned short sems=0;
- int i,n;
+ int n;
ipcinfo_sem = (ipcinfo_sem_t *)ipc_get_info(0,
GET_IPCINFO_SEM_ALL, IPCINFO_SEM_VERSION, sizeof(ipcinfo_sem_t), &n);
if (ipcinfo_sem == NULL)
return -1;
- for (i=0; i<n; i++) {
+ for (int i=0; i<n; i++) {
sem_nsems += ipcinfo_sem[i].sem_nsems;
sems++;
}
ipcinfo_shm_t *pshm;
unsigned int shm_segments=0;
size64_t shm_bytes=0;
- int i,n;
+ int n;
ipcinfo_shm = (ipcinfo_shm_t *)ipc_get_info(0,
GET_IPCINFO_SHM_ALL, IPCINFO_SHM_VERSION, sizeof(ipcinfo_shm_t), &n);
if (ipcinfo_shm == NULL)
return -1;
- for (i=0, pshm=ipcinfo_shm; i<n; i++, pshm++) {
+ for (int i=0, pshm=ipcinfo_shm; i<n; i++, pshm++) {
shm_segments++;
shm_bytes += pshm->shm_segsz;
}
uint32_t msg_used_space=0;
uint32_t msg_alloc_queues=0;
msgqnum32_t msg_qnum=0;
- int i,n;
+ int n;
ipcinfo_msg = (ipcinfo_msg_t *)ipc_get_info(0,
GET_IPCINFO_MSG_ALL, IPCINFO_MSG_VERSION, sizeof(ipcinfo_msg_t), &n);
if (ipcinfo_msg == NULL)
return -1;
- for (i=0; i<n; i++) {
+ for (int i=0; i<n; i++) {
msg_alloc_queues++;
msg_used_space += ipcinfo_msg[i].msg_cbytes;
msg_qnum += ipcinfo_msg[i].msg_qnum;
static int sensor_list_read_all (void)
{
- c_ipmi_sensor_list_t *list_item;
-
pthread_mutex_lock (&sensor_list_lock);
- for (list_item = sensor_list;
+ for (c_ipmi_sensor_list_t *list_item = sensor_list;
list_item != NULL;
list_item = list_item->next)
{
static int iptables_read (void)
{
- int i;
int num_failures = 0;
ip_chain_t *chain;
/* Init the iptc handle structure and query the correct table */
- for (i = 0; i < chain_num; i++)
+ for (int i = 0; i < chain_num; i++)
{
chain = chain_list[i];
static int iptables_shutdown (void)
{
- int i;
-
- for (i = 0; i < chain_num; i++)
+ for (int i = 0; i < chain_num; i++)
{
if ((chain_list[i] != NULL) && (chain_list[i]->rule_type == RTYPE_COMMENT))
sfree (chain_list[i]->rule.comment);
char pi[DATA_MAX_NAME_LEN];
- size_t i;
-
if (0 != get_pi (se, pi, sizeof (pi)))
{
free (dests);
cipvs_submit_if (pi, "if_packets", NULL, stats.inpkts, stats.outpkts);
cipvs_submit_if (pi, "if_octets", NULL, stats.inbytes, stats.outbytes);
- for (i = 0; i < dests->num_dests; ++i)
+ for (size_t i = 0; i < dests->num_dests; ++i)
cipvs_submit_dest (pi, &dests->entrytable[i]);
free (dests);
static int cipvs_read (void)
{
struct ip_vs_get_services *services = NULL;
- size_t i;
if (sockfd < 0)
return (-1);
if (NULL == (services = ipvs_get_services ()))
return -1;
- for (i = 0; i < services->num_services; ++i)
+ for (size_t i = 0; i < services->num_services; ++i)
cipvs_submit_service (&services->entrytable[i]);
free (services);
jmethodID m_addchild;
jobject o_key;
jobject o_ocitem;
- int i;
c_ocitem = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/OConfigItem");
if (c_ocitem == NULL)
(*jvm_env)->DeleteLocalRef (jvm_env, o_key);
/* Call OConfigItem.addValue for each value */
- for (i = 0; i < ci->values_num; i++) /* {{{ */
+ for (int i = 0; i < ci->values_num; i++) /* {{{ */
{
jobject o_value;
} /* }}} for (i = 0; i < ci->values_num; i++) */
/* Call OConfigItem.addChild for each child */
- for (i = 0; i < ci->children_num; i++) /* {{{ */
+ for (int i = 0; i < ci->children_num; i++) /* {{{ */
{
jobject o_child;
jmethodID m_add;
jobject o_type;
jobject o_dataset;
- size_t i;
/* Look up the org/collectd/api/DataSet class */
c_dataset = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/DataSet");
/* Decrease reference counter on the java.lang.String object. */
(*jvm_env)->DeleteLocalRef (jvm_env, o_type);
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
jobject o_datasource;
jmethodID m_valuelist_constructor;
jobject o_valuelist;
int status;
- size_t i;
/* First, create a new ValueList instance..
* Look up the class.. */
return (NULL);
}
- for (i = 0; i < vl->values_len; i++)
+ for (size_t i = 0; i < vl->values_len; i++)
{
status = ctoj_value_list_add_value (jvm_env, vl->values[i], ds->ds[i].type,
c_valuelist, o_valuelist);
value_t *values;
int values_num;
- int i;
values_num = ds->ds_num;
BAIL_OUT (-1);
}
- for (i = 0; i < values_num; i++)
+ for (int i = 0; i < values_num; i++)
{
jobject o_number;
int status;
JavaVMOption vm_options[jvm_argc];
int status;
- size_t i;
if (jvm != NULL)
return (0);
vm_args.options = vm_options;
vm_args.nOptions = (jint) jvm_argc;
- for (i = 0; i < jvm_argc; i++)
+ for (size_t i = 0; i < jvm_argc; i++)
{
DEBUG ("java plugin: cjni_create_jvm: jvm_argv[%zu] = %s",
i, jvm_argv[i]);
{ /* Replace all dots ('.') with slashes ('/'). Dots are usually used
thorough the Java community, but (Sun's) `FindClass' and friends need
slashes. */
- size_t i;
- for (i = 0; class->name[i] != 0; i++)
+ for (size_t i = 0; class->name[i] != 0; i++)
if (class->name[i] == '.')
class->name[i] = '/';
}
cjni_callback_info_t *cbi;
jobject o_ocitem;
const char *name;
- size_t i;
jclass class;
jmethodID method;
name = ci->values[0].value.string;
cbi = NULL;
- for (i = 0; i < java_callbacks_num; i++)
+ for (size_t i = 0; i < java_callbacks_num; i++)
{
if (java_callbacks[i].type != CB_TYPE_CONFIG)
continue;
int success;
int errors;
int status;
- int i;
success = 0;
errors = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
jobject o_ci;
jobject o_tmp;
int type;
- size_t i;
cbi_ret = NULL;
o_ci = NULL;
/* Lets see if we have a matching factory here.. */
cbi_factory = NULL;
- for (i = 0; i < java_callbacks_num; i++)
+ for (size_t i = 0; i < java_callbacks_num; i++)
{
if (java_callbacks[i].type != type)
continue;
static int cjni_init_plugins (JNIEnv *jvm_env) /* {{{ */
{
int status;
- size_t i;
- for (i = 0; i < java_callbacks_num; i++)
+ for (size_t i = 0; i < java_callbacks_num; i++)
{
if (java_callbacks[i].type != CB_TYPE_INIT)
continue;
static int cjni_shutdown_plugins (JNIEnv *jvm_env) /* {{{ */
{
int status;
- size_t i;
- for (i = 0; i < java_callbacks_num; i++)
+ for (size_t i = 0; i < java_callbacks_num; i++)
{
if (java_callbacks[i].type != CB_TYPE_SHUTDOWN)
continue;
JNIEnv *jvm_env;
JavaVMAttachArgs args = { 0 };
int status;
- size_t i;
if (jvm == NULL)
return (0);
cjni_shutdown_plugins (jvm_env);
/* Release all the global references to callback functions */
- for (i = 0; i < java_callbacks_num; i++)
+ for (size_t i = 0; i < java_callbacks_num; i++)
{
if (java_callbacks[i].object != NULL)
{
sfree (java_callbacks);
/* Release all the global references to directly loaded classes. */
- for (i = 0; i < java_classes_list_len; i++)
+ for (size_t i = 0; i < java_classes_list_len; i++)
{
if (java_classes_list[i].object != NULL)
{
pthread_key_delete (jvm_env_key);
/* Free the JVM argument list */
- for (i = 0; i < jvm_argc; i++)
+ for (size_t i = 0; i < jvm_argc; i++)
sfree (jvm_argv[i]);
jvm_argc = 0;
sfree (jvm_argv);
static void lcc_response_free (lcc_response_t *res) /* {{{ */
{
- size_t i;
-
if (res == NULL)
return;
- for (i = 0; i < res->lines_num; i++)
+ for (size_t i = 0; i < res->lines_num; i++)
free (res->lines[i]);
free (res->lines);
res->lines = NULL;
const char *addr_orig)
{
struct addrinfo *ai_res;
- struct addrinfo *ai_ptr;
char addr_copy[NI_MAXHOST];
char *addr;
char *port;
return (-1);
}
- for (ai_ptr = ai_res; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_res; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
if (fd < 0)
char command[1024] = "";
lcc_response_t res;
int status;
- size_t i;
if ((c == NULL) || (vl == NULL) || (vl->values_len < 1)
|| (vl->values == NULL) || (vl->values_types == NULL))
else
SSTRCAT (command, " N");
- for (i = 0; i < vl->values_len; i++)
+ for (size_t i = 0; i < vl->values_len; i++)
{
if (vl->values_types[i] == LCC_TYPE_COUNTER)
SSTRCATF (command, ":%"PRIu64, vl->values[i].counter);
lcc_identifier_t **ret_ident, size_t *ret_ident_num)
{
lcc_response_t res;
- size_t i;
int status;
lcc_identifier_t *ident;
return (-1);
}
- for (i = 0; i < res.lines_num; i++)
+ for (size_t i = 0; i < res.lines_num; i++)
{
char *time_str;
char *ident_str;
static int server_open_socket (lcc_server_t *srv) /* {{{ */
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
if (srv == NULL)
return (status);
assert (ai_list != NULL);
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
srv->fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
if (srv->fd < 0)
int lcc_network_values_send (lcc_network_t *net, /* {{{ */
const lcc_value_list_t *vl)
{
- lcc_server_t *srv;
-
if ((net == NULL) || (vl == NULL))
return (EINVAL);
- for (srv = net->servers; srv != NULL; srv = srv->next)
+ for (lcc_server_t *srv = net->servers; srv != NULL; srv = srv->next)
server_value_add (srv, vl);
return (0);
value_t pkg_values[vl->values_len];
size_t offset;
- size_t i;
packet_len = sizeof (pkg_type) + sizeof (pkg_length)
+ sizeof (pkg_num_values)
pkg_length = htons ((uint16_t) packet_len);
pkg_num_values = htons ((uint16_t) vl->values_len);
- for (i = 0; i < vl->values_len; i++)
+ for (size_t i = 0; i < vl->values_len; i++)
{
pkg_values_types[i] = (uint8_t) vl->values_types[i];
switch (vl->values_types[i])
if (ci_orig->values_num > 0) /* {{{ */
{
- int i;
-
ci_copy->values = (oconfig_value_t *) calloc ((size_t) ci_orig->values_num,
sizeof (*ci_copy->values));
if (ci_copy->values == NULL)
}
ci_copy->values_num = ci_orig->values_num;
- for (i = 0; i < ci_copy->values_num; i++)
+ for (int i = 0; i < ci_copy->values_num; i++)
{
ci_copy->values[i].type = ci_orig->values[i].type;
if (ci_copy->values[i].type == OCONFIG_TYPE_STRING)
if (ci_orig->children_num > 0) /* {{{ */
{
- int i;
-
ci_copy->children = (oconfig_item_t *) calloc ((size_t) ci_orig->children_num,
sizeof (*ci_copy->children));
if (ci_copy->children == NULL)
}
ci_copy->children_num = ci_orig->children_num;
- for (i = 0; i < ci_copy->children_num; i++)
+ for (int i = 0; i < ci_copy->children_num; i++)
{
oconfig_item_t *child;
static void oconfig_free_all (oconfig_item_t *ci)
{
- int i;
-
if (ci == NULL)
return;
if (ci->key != NULL)
free (ci->key);
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
if ((ci->values[i].type == OCONFIG_TYPE_STRING)
&& (NULL != ci->values[i].value.string))
free (ci->values[i].value.string);
if (ci->values != NULL)
free (ci->values);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
oconfig_free_all (ci->children + i);
if (ci->children != NULL)
{
char *ret = strdup (orig);
int len;
- int i;
if (ret == NULL)
return (NULL);
memmove (ret, ret + 1, len);
ret[len] = '\0';
- for (i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
{
if (ret[i] == '\\')
{
static inline void watchlist_set (uint32_t *wl, uint32_t val)
{
- int i;
- for (i = 0; i < WL_LEN; i++)
+ for (int i = 0; i < WL_LEN; i++)
wl[i] = val;
}
static int watchitem_find (const char *name)
{
int max = STATIC_ARRAY_SIZE (specs);
- int i;
- for (i = 0; i < max; i++)
+ for (int i = 0; i < max; i++)
if (strcasecmp (name, specs[i].name) == 0)
return i;
static int madwifi_real_init (void)
{
size_t max = STATIC_ARRAY_SIZE (specs);
- size_t i;
- for (i = 0; i < STATIC_ARRAY_SIZE (bounds); i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (bounds); i++)
bounds[i] = 0;
watchlist_set(watch_items, 0);
watchlist_set(misc_items, 0);
- for (i = 0; i < max; i++)
+ for (size_t i = 0; i < max; i++)
{
bounds[specs[i].flags & SRC_MASK] = i;
misc_items[i / 32] |= FLAG (i);
}
- for (i = 0; i < STATIC_ARRAY_SIZE (bounds); i++)
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (bounds); i++)
bounds[i]++;
return (0);
u_int32_t *vals, int vals_num)
{
char ti2[16];
- int i;
- for (i = 0; i < vals_num; i++)
+ for (int i = 0; i < vals_num; i++)
{
if (vals[i] == 0)
continue;
const char *type_name, const char *misc_name)
{
uint32_t misc = 0;
- int i;
assert (which >= 1);
assert (((size_t) which) < STATIC_ARRAY_SIZE (bounds));
- for (i = bounds[which - 1]; i < bounds[which]; i++)
+ for (int i = bounds[which - 1]; i < bounds[which]; i++)
{
uint32_t val = *(uint32_t *)(((char *) ptr) + specs[i].offset) ;
{
int num_counters = 0;
int num_empty = 0;
- size_t i;
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if ((ds->ds[i].type != DS_TYPE_DERIVE)
&& (ds->ds[i].type != DS_TYPE_COUNTER))
static int mh_create (const oconfig_item_t *ci, void **user_data) /* {{{ */
{
mh_match_t *m;
- int i;
m = calloc (1, sizeof (*m));
if (m == NULL)
return (-ENOMEM);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
mh_match_t *m;
uint32_t hash_val;
- const char *host_ptr;
- size_t i;
if ((user_data == NULL) || (*user_data == NULL))
return (-1);
hash_val = 0;
- for (host_ptr = vl->host; *host_ptr != 0; host_ptr++)
+ for (const char *host_ptr = vl->host; *host_ptr != 0; host_ptr++)
{
/* 2184401929 is some appropriately sized prime number. */
hash_val = (hash_val * UINT32_C (2184401929)) + ((uint32_t) *host_ptr);
}
DEBUG ("hashed match: host = %s; hash_val = %"PRIu32";", vl->host, hash_val);
- for (i = 0; i < m->matches_num; i++)
+ for (size_t i = 0; i < m->matches_num; i++)
if ((hash_val % m->matches[i].total) == m->matches[i].match)
return (FC_MATCH_MATCHES);
static int mr_match_regexen (mr_regex_t *re_head, /* {{{ */
const char *string)
{
- mr_regex_t *re;
-
if (re_head == NULL)
return (FC_MATCH_MATCHES);
- for (re = re_head; re != NULL; re = re->next)
+ for (mr_regex_t *re = re_head; re != NULL; re = re->next)
{
int status;
{
mr_match_t *m;
int status;
- int i;
m = calloc (1, sizeof (*m));
if (m == NULL)
m->invert = 0;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
mt_match_t *m;
int status;
- int i;
m = calloc (1, sizeof (*m));
if (m == NULL)
m->past = 0;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
*/
static void mv_free_match (mv_match_t *m) /* {{{ */
{
- size_t i;
-
if (m == NULL)
return;
if (m->data_sources != NULL)
{
- for (i = 0; i < m->data_sources_num; ++i)
+ for (size_t i = 0; i < m->data_sources_num; ++i)
free(m->data_sources[i]);
free(m->data_sources);
}
{
size_t new_data_sources_num;
char **temp;
- int i;
/* Check number of arbuments. */
if (ci->values_num < 1)
}
/* Check type of arguments */
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
if (ci->values[i].type == OCONFIG_TYPE_STRING)
continue;
m->data_sources = temp;
/* Copy the strings, allocating memory as needed. */
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
- size_t j;
-
/* If we get here, there better be memory for us to write to. */
assert (m->data_sources_num < new_data_sources_num);
- j = m->data_sources_num;
+ size_t j = m->data_sources_num;
m->data_sources[j] = sstrdup (ci->values[i].value.string);
if (m->data_sources[j] == NULL)
{
{
mv_match_t *m;
int status;
- int i;
m = calloc (1, sizeof (*m));
if (m == NULL)
m->data_sources_num = 0;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
mv_match_t *m;
gauge_t *values;
int status;
- size_t i;
if ((user_data == NULL) || (*user_data == NULL))
return (-1);
status = FC_MATCH_NO_MATCH;
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
int value_matches = 0;
const char *host;
const char *port;
- struct addrinfo *ai_list, *ai_ptr;
+ struct addrinfo *ai_list;
int ai_return;
host = mbmon_host;
}
fd = -1;
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
/* create our socket descriptor */
if ((fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol)) < 0)
/* Trim trailing whitespace from a string. */
static void trim_spaces (char *s)
{
- size_t l;
-
- for (l = strlen (s) - 1; (l > 0) && isspace ((int) s[l]); l--)
+ for (size_t l = strlen (s) - 1; (l > 0) && isspace ((int) s[l]); l--)
s[l] = '\0';
}
{
web_match_t *match;
int status;
- int i;
if (ci->values_num != 0)
{
}
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
web_page_t *page;
int status;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
/* Process all children */
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
int success;
int errors;
int status;
- int i;
success = 0;
errors = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int cmc_read_page (web_page_t *wp) /* {{{ */
{
- web_match_t *wm;
memcached_return rc;
size_t string_length;
uint32_t flags;
return (-1);
}
- for (wm = wp->matches; wm != NULL; wm = wm->next)
+ for (web_match_t *wm = wp->matches; wm != NULL; wm = wm->next)
{
cu_match_value_t *mv;
static int cmc_read (void) /* {{{ */
{
- web_page_t *wp;
-
- for (wp = pages_g; wp != NULL; wp = wp->next)
+ for (web_page_t *wp = pages_g; wp != NULL; wp = wp->next)
cmc_read_page (wp);
return (0);
const char *host;
const char *port;
- struct addrinfo *ai_list, *ai_ptr;
+ struct addrinfo *ai_list;
int status;
int fd = -1;
return (-1);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
/* create our socket descriptor */
fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
static int config_add_instance(oconfig_item_t *ci)
{
memcached_t *st;
- int i;
int status = 0;
/* Disable automatic generation of default instance in the init callback. */
}
assert (st->name != NULL);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
int status = 0;
_Bool have_instance_block = 0;
- int i;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int memory_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("ValuesAbsolute", child->key) == 0)
};
double sysctl_vals[8];
- int i;
-
- for (i = 0; sysctl_keys[i] != NULL; i++)
+ for (int i = 0; sysctl_keys[i] != NULL; i++)
{
int value;
size_t value_len = sizeof (value);
} /* for (sysctl_keys) */
/* multiply all all page counts with the pagesize */
- for (i = 1; sysctl_keys[i] != NULL; i++)
+ for (int i = 1; sysctl_keys[i] != NULL; i++)
if (!isnan (sysctl_vals[i]))
sysctl_vals[i] *= sysctl_vals[0];
static int mic_read_temps(int mic)
{
size_t num_therms = STATIC_ARRAY_SIZE(therm_ids);
- size_t j;
- for (j = 0; j < num_therms; j++) {
+ for (size_t j = 0; j < num_therms; j++) {
U32 status;
U32 temp_buffer;
U32 buffer_size = (U32)sizeof(temp_buffer);
}
if (show_cpu_cores) {
- int j;
- for (j = 0; j < core_util.core; j++) {
+ for (int j = 0; j < core_util.core; j++) {
mic_submit_cpu(mic, "user", j, core_jiffs[j].user);
mic_submit_cpu(mic, "sys", j, core_jiffs[j].sys);
mic_submit_cpu(mic, "nice", j, core_jiffs[j].nice);
static int mic_read (void)
{
- int i;
U32 ret;
int error;
error=0;
- for (i=0;i<num_mics;i++) {
+ for (int i=0;i<num_mics;i++) {
ret = MicInitAdapter(&mic_handle,&mics[i]);
if (ret != MIC_ACCESS_API_SUCCESS) {
ERROR("mic plugin: Problem initializing MicAdapter: %s",
static mb_data_t *data_get_by_name (mb_data_t *src, /* {{{ */
const char *name)
{
- mb_data_t *ptr;
-
if (name == NULL)
return (NULL);
- for (ptr = src; ptr != NULL; ptr = ptr->next)
+ for (mb_data_t *ptr = src; ptr != NULL; ptr = ptr->next)
if (strcasecmp (ptr->name, name) == 0)
return (ptr);
static int mb_read_slave (mb_host_t *host, mb_slave_t *slave) /* {{{ */
{
- mb_data_t *data;
int success;
int status;
return (EINVAL);
success = 0;
- for (data = slave->collect; data != NULL; data = data->next)
+ for (mb_data_t *data = slave->collect; data != NULL; data = data->next)
{
status = mb_read_data (host, slave, data);
if (status == 0)
static int mb_read (user_data_t *user_data) /* {{{ */
{
mb_host_t *host;
- size_t i;
int success;
int status;
host = user_data->data;
success = 0;
- for (i = 0; i < host->slaves_num; i++)
+ for (size_t i = 0; i < host->slaves_num; i++)
{
status = mb_read_slave (host, host->slaves + i);
if (status == 0)
static void slaves_free_all (mb_slave_t *slaves, size_t slaves_num) /* {{{ */
{
- size_t i;
-
if (slaves == NULL)
return;
- for (i = 0; i < slaves_num; i++)
+ for (size_t i = 0; i < slaves_num; i++)
data_free_all (slaves[i].collect);
sfree (slaves);
} /* }}} void slaves_free_all */
{
mb_data_t data = { 0 };
int status;
- int i;
data.name = NULL;
data.register_type = REG_TYPE_UINT16;
if (status != 0)
return (status);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
const char *address)
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
if ((host == NULL) || (address == NULL))
return (status);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
status = getnameinfo (ai_ptr->ai_addr, ai_ptr->ai_addrlen,
host->node, sizeof (host->node),
{
mb_slave_t *slave;
int status;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
if (status != 0)
return (status);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
mb_host_t *host;
int status;
- int i;
host = calloc (1, sizeof (*host));
if (host == NULL)
return (EINVAL);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
status = 0;
static int mb_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
if (ci == NULL)
return (EINVAL);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static char *strip_prefix (char *topic)
{
- size_t num;
- size_t i;
+ size_t num = 0;
- num = 0;
- for (i = 0; topic[i] != 0; i++)
+ for (size_t i = 0; topic[i] != 0; i++)
if (topic[i] == '/')
num++;
char cb_name[1024];
user_data_t user_data = { 0 };
int status;
- int i;
conf = calloc (1, sizeof (*conf));
if (conf == NULL)
C_COMPLAIN_INIT (&conf->complaint_cantpublish);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Host", child->key) == 0)
mqtt_client_conf_t **tmp;
mqtt_client_conf_t *conf;
int status;
- int i;
conf = calloc (1, sizeof (*conf));
if (conf == NULL)
C_COMPLAIN_INIT (&conf->complaint_cantpublish);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Host", child->key) == 0)
*/
static int mqtt_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int mqtt_init (void)
{
- size_t i;
-
mosquitto_lib_init ();
- for (i = 0; i < subscribers_num; i++)
+ for (size_t i = 0; i < subscribers_num; i++)
{
int status;
static int multimeter_init (void)
{
- int i;
char device[] = "/dev/ttyS ";
- for (i = 0; i < 10; i++)
+ for (int i = 0; i < 10; i++)
{
device[strlen(device)-1] = i + '0';
{
mysql_database_t *db;
int status = 0;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
assert (db->instance != NULL);
/* Fill the `mysql_database_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int mysql_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
if (ci == NULL)
return (EINVAL);
/* Fill the `mysql_database_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
const char *plugin_inst;
na_elem_t *instances;
- na_elem_t *counter;
na_elem_iter_t counter_iter;
perf_data.timestamp = cna_child_get_cdtime (data);
/* Iterate over all counters */
counter_iter = na_child_iterator (na_elem_child (instances, "counters"));
- for (counter = na_iterator_next (&counter_iter);
+ for (na_elem_t *counter = na_iterator_next (&counter_iter);
counter != NULL;
counter = na_iterator_next (&counter_iter))
{
{
cdtime_t timestamp;
na_elem_t *instances;
- na_elem_t *instance;
na_elem_iter_t instance_iter;
disk_t *worst_disk = NULL;
/* Iterate over all children */
instance_iter = na_child_iterator (instances);
- for (instance = na_iterator_next (&instance_iter);
+ for (na_elem_t *instance = na_iterator_next (&instance_iter);
instance != NULL;
instance = na_iterator_next(&instance_iter))
{
disk_t new_data = { 0 };
na_elem_iter_t counter_iterator;
- na_elem_t *counter;
new_data.timestamp = timestamp;
new_data.disk_busy_percent = NAN;
/* Look for the "disk_busy" and "base_for_disk_busy" counters */
counter_iterator = na_child_iterator(na_elem_child(instance, "counters"));
- for (counter = na_iterator_next(&counter_iterator);
+ for (na_elem_t *counter = na_iterator_next(&counter_iterator);
counter != NULL;
counter = na_iterator_next(&counter_iterator))
{
cdtime_t timestamp;
na_elem_t *elem_instances;
na_elem_iter_t iter_instances;
- na_elem_t *elem_instance;
timestamp = cna_child_get_cdtime (data);
}
iter_instances = na_child_iterator (elem_instances);
- for (elem_instance = na_iterator_next(&iter_instances);
+ for (na_elem_t *elem_instance = na_iterator_next(&iter_instances);
elem_instance != NULL;
elem_instance = na_iterator_next(&iter_instances))
{
na_elem_t *elem_counters;
na_elem_iter_t iter_counters;
- na_elem_t *elem_counter;
perf_data.timestamp = timestamp;
continue;
iter_counters = na_child_iterator (elem_counters);
- for (elem_counter = na_iterator_next(&iter_counters);
+ for (na_elem_t *elem_counter = na_iterator_next(&iter_counters);
elem_counter != NULL;
elem_counter = na_iterator_next(&iter_counters))
{
static int cna_submit_volume_usage_data (const char *hostname, /* {{{ */
cfg_volume_usage_t *cfg_volume, int interval)
{
- data_volume_usage_t *v;
-
- for (v = cfg_volume->volumes; v != NULL; v = v->next)
+ for (data_volume_usage_t *v = cfg_volume->volumes; v != NULL; v = v->next)
{
char plugin_instance[DATA_MAX_NAME_LEN];
data_volume_usage_t *v)
{
uint64_t snap_used = 0, value;
- na_elem_t *data, *elem_snap, *elem_snapshots;
+ na_elem_t *data, *elem_snapshots;
na_elem_iter_t iter_snap;
data = na_server_invoke_elem(host->srv, v->snap_query);
}
iter_snap = na_child_iterator (elem_snapshots);
- for (elem_snap = na_iterator_next (&iter_snap);
+ for (na_elem_t *elem_snap = na_iterator_next (&iter_snap);
elem_snap != NULL;
elem_snap = na_iterator_next (&iter_snap))
{
static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */
cfg_volume_usage_t *cfg_volume, na_elem_t *data)
{
- na_elem_t *elem_volume;
na_elem_t *elem_volumes;
na_elem_iter_t iter_volume;
}
iter_volume = na_child_iterator (elem_volumes);
- for (elem_volume = na_iterator_next (&iter_volume);
+ for (na_elem_t *elem_volume = na_iterator_next (&iter_volume);
elem_volume != NULL;
elem_volume = na_iterator_next (&iter_volume))
{
static int cna_handle_quota_data (const host_config_t *host, /* {{{ */
cfg_quota_t *cfg_quota, na_elem_t *data)
{
- na_elem_t *elem_quota;
na_elem_t *elem_quotas;
na_elem_iter_t iter_quota;
}
iter_quota = na_child_iterator (elem_quotas);
- for (elem_quota = na_iterator_next (&iter_quota);
+ for (na_elem_t *elem_quota = na_iterator_next (&iter_quota);
elem_quota != NULL;
elem_quota = na_iterator_next (&iter_quota))
{
static int cna_handle_snapvault_data (const char *hostname, /* {{{ */
cfg_snapvault_t *cfg_snapvault, na_elem_t *data, cdtime_t interval)
{
- na_elem_t *status;
na_elem_iter_t status_iter;
status = na_elem_child (data, "status-list");
}
status_iter = na_child_iterator (status);
- for (status = na_iterator_next (&status_iter);
+ for (na_elem_t *status = na_iterator_next (&status_iter);
status != NULL;
status = na_iterator_next (&status_iter))
{
const char *tag;
uint32_t records_count;
- uint32_t i;
records_count = na_child_get_uint32 (data, "records", UINT32_MAX);
if (records_count == UINT32_MAX)
DEBUG ("netapp plugin: Iterating %u SV records (tag = %s)", records_count, tag);
- for (i = 0; i < records_count; ++i) {
+ for (uint32_t i = 0; i < records_count; ++i) {
na_elem_t *elem;
elem = na_server_invoke (host->srv,
cfg_system_t *cfg_system, na_elem_t *data, int interval)
{
na_elem_t *instances;
- na_elem_t *counter;
na_elem_iter_t counter_iter;
derive_t disk_read = 0, disk_written = 0;
}
counter_iter = na_child_iterator (na_elem_child (instances, "counters"));
- for (counter = na_iterator_next (&counter_iter);
+ for (na_elem_t *counter = na_iterator_next (&counter_iter);
counter != NULL;
counter = na_iterator_next (&counter_iter))
{
const oconfig_item_t *ci)
{
cfg_volume_perf_t *cfg_volume_perf;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
}
cfg_volume_perf = host->cfg_volume_perf;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
/* if (!item || !item->key || !*item->key) continue; */
static int cna_config_quota (host_config_t *host, oconfig_item_t *ci) /* {{{ */
{
cfg_quota_t *cfg_quota;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
}
cfg_quota = host->cfg_quota;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
if (strcasecmp (item->key, "Interval") == 0)
/* Corresponds to a <Disks /> block */
static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
cfg_disk_t *cfg_disk;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
}
cfg_disk = host->cfg_disk;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
/* if (!item || !item->key || !*item->key) continue; */
static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */
{
cfg_wafl_t *cfg_wafl;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
}
cfg_wafl = host->cfg_wafl;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
if (strcasecmp(item->key, "Interval") == 0)
const oconfig_item_t *ci)
{
cfg_volume_usage_t *cfg_volume_usage;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
}
cfg_volume_usage = host->cfg_volume_usage;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
/* if (!item || !item->key || !*item->key) continue; */
const oconfig_item_t *ci)
{
cfg_snapvault_t *cfg_snapvault;
- int i;
if ((host == NULL) || (ci == NULL))
return EINVAL;
cfg_snapvault = host->cfg_snapvault;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
if (strcasecmp (item->key, "Interval") == 0)
oconfig_item_t *ci)
{
cfg_system_t *cfg_system;
- int i;
if ((host == NULL) || (ci == NULL))
return (EINVAL);
}
cfg_system = host->cfg_system;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
if (strcasecmp(item->key, "Interval") == 0) {
oconfig_item_t *item;
_Bool is_vfiler = 0;
int status;
- int i;
if (! strcasecmp (ci->key, "VFiler"))
is_vfiler = 1;
if (status != 0)
return (1);
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
item = ci->children + i;
status = 0;
} /* }}} int cna_read */
static int cna_config (oconfig_item_t *ci) { /* {{{ */
- int i;
oconfig_item_t *item;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
item = ci->children + i;
if (strcasecmp(item->key, "Host") == 0)
static int check_ignorelist (const char *dev,
const char *type, const char *type_instance)
{
- ir_ignorelist_t *i;
-
assert ((dev != NULL) && (type != NULL));
if (ir_ignorelist_head == NULL)
return (ir_ignorelist_invert ? 0 : 1);
- for (i = ir_ignorelist_head; i != NULL; i = i->next)
+ for (ir_ignorelist_t *i = ir_ignorelist_head; i != NULL; i = i->next)
{
/* i->device == NULL => match all devices */
if ((i->device != NULL)
int ret;
unsigned int seq, portid;
- size_t ifindex;
-
static const int type_id[] = { RTM_GETQDISC, RTM_GETTCLASS, RTM_GETTFILTER };
static const char *type_name[] = { "qdisc", "class", "filter" };
/* `link_filter_cb' will update `iflist' which is used here to iterate
* over all interfaces. */
- for (ifindex = 1; ifindex < iflist_len; ifindex++)
+ for (size_t ifindex = 1; ifindex < iflist_len; ifindex++)
{
struct tcmsg *tm;
- size_t type_index;
if (iflist[ifindex] == NULL)
continue;
- for (type_index = 0; type_index < STATIC_ARRAY_SIZE (type_id); type_index++)
+ for (size_t type_index = 0; type_index < STATIC_ARRAY_SIZE (type_id); type_index++)
{
if (check_ignorelist (iflist[ifindex], type_name[type_index], NULL))
{
static _Bool check_notify_received (const notification_t *n) /* {{{ */
{
- notification_meta_t *ptr;
-
- for (ptr = n->meta; ptr != NULL; ptr = ptr->next)
+ for (notification_meta_t *ptr = n->meta; ptr != NULL; ptr = ptr->next)
if ((strcmp ("network:received", ptr->name) == 0)
&& (ptr->type == NM_TYPE_BOOLEAN))
return ((_Bool) ptr->nm_value.nm_boolean);
value_t *pkg_values;
size_t offset;
- int i;
num_values = vl->values_len;
packet_len = sizeof (part_header_t) + sizeof (uint16_t)
pkg_num_values = htons ((uint16_t) vl->values_len);
- for (i = 0; i < num_values; i++)
+ for (int i = 0; i < num_values; i++)
{
pkg_values_types[i] = (uint8_t) ds->ds[i].type;
switch (ds->ds[i].type)
uint16_t tmp16;
size_t exp_size;
- size_t i;
uint16_t pkg_length;
uint16_t pkg_type;
memcpy (pkg_values, buffer, pkg_numval * sizeof (*pkg_values));
buffer += pkg_numval * sizeof (*pkg_values);
- for (i = 0; i < pkg_numval; i++)
+ for (size_t i = 0; i < pkg_numval; i++)
{
switch (pkg_types[i])
{
static void free_sockent_server (struct sockent_server *ses) /* {{{ */
{
- size_t i;
-
- for (i = 0; i < ses->fd_num; i++)
+ for (size_t i = 0; i < ses->fd_num; i++)
{
if (ses->fd[i] >= 0)
{
static c_complain_t complaint = C_COMPLAIN_INIT_STATIC;
struct sockent_client *client;
- struct addrinfo *ai_list, *ai_ptr;
+ struct addrinfo *ai_list;
int status;
_Bool reconnect = 0;
cdtime_t now;
se->node);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
if (client->fd >= 0) /* when we reconnect */
sockent_client_disconnect(se);
/* Open the file descriptors for a initialized sockent structure. */
static int sockent_server_listen (sockent_t *se) /* {{{ */
{
- struct addrinfo *ai_list, *ai_ptr;
+ struct addrinfo *ai_list;
int status;
const char *node;
return (-1);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
int *tmp;
if (se->type == SOCKENT_TYPE_SERVER)
{
struct pollfd *tmp;
- size_t i;
tmp = realloc (listen_sockets_pollfd,
sizeof (*tmp) * (listen_sockets_num
listen_sockets_pollfd = tmp;
tmp = listen_sockets_pollfd + listen_sockets_num;
- for (i = 0; i < se->data.server.fd_num; i++)
+ for (size_t i = 0; i < se->data.server.fd_num; i++)
{
memset (tmp + i, 0, sizeof (*tmp));
tmp[i].fd = se->data.server.fd[i];
char buffer[network_config_packet_size];
int buffer_len;
- size_t i;
int status = 0;
receive_list_entry_t *private_list_head;
break;
}
- for (i = 0; (i < listen_sockets_num) && (status > 0); i++)
+ for (size_t i = 0; (i < listen_sockets_num) && (status > 0); i++)
{
receive_list_entry_t *ent;
static void network_send_buffer (char *buffer, size_t buffer_len) /* {{{ */
{
- sockent_t *se;
-
DEBUG ("network plugin: network_send_buffer: buffer_len = %zu", buffer_len);
- for (se = sending_sockets; se != NULL; se = se->next)
+ for (sockent_t *se = sending_sockets; se != NULL; se = se->next)
{
#if HAVE_LIBGCRYPT
if (se->data.client.security_level == SECURITY_LEVEL_ENCRYPT)
{
sockent_t *se;
int status;
- int i;
if ((ci->values_num < 1) || (ci->values_num > 2)
|| (ci->values[0].type != OCONFIG_TYPE_STRING)
if (ci->values_num >= 2)
se->service = strdup (ci->values[1].value.string);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
sockent_t *se;
int status;
- int i;
if ((ci->values_num < 1) || (ci->values_num > 2)
|| (ci->values[0].type != OCONFIG_TYPE_STRING)
if (ci->values_num >= 2)
se->service = strdup (ci->values[1].value.string);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int network_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
/* The options need to be applied first */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("TimeToLive", child->key) == 0)
network_config_set_ttl (child);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int network_shutdown (void)
{
- sockent_t *se;
-
listen_loop++;
/* Kill the listening thread */
sfree (send_buffer);
- for (se = sending_sockets; se != NULL; se = se->next)
+ for (sockent_t *se = sending_sockets; se != NULL; se = se->next)
sockent_client_disconnect (se);
sockent_destroy (sending_sockets);
#elif HAVE_LIBKSTAT
static int nfs_init (void)
{
- kstat_t *ksp_chain = NULL;
-
nfs2_ksp_client = NULL;
nfs2_ksp_server = NULL;
nfs3_ksp_client = NULL;
if (kc == NULL)
return (-1);
- for (ksp_chain = kc->kc_chain; ksp_chain != NULL;
+ for (kstat_t *ksp_chain = kc->kc_chain; ksp_chain != NULL;
ksp_chain = ksp_chain->ks_next)
{
if (strncmp (ksp_chain->ks_module, "nfs", 3) != 0)
value_t *values, size_t values_num)
{
value_list_t vl = VALUE_LIST_INIT;
- size_t i;
vl.values_len = 1;
sstrncpy (vl.host, hostname_g, sizeof (vl.host));
sizeof (vl.plugin_instance));
sstrncpy (vl.type, "nfs_procedure", sizeof (vl.type));
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
{
vl.values = values + i;
sstrncpy (vl.type_instance, type_instances[i],
{
char plugin_instance[DATA_MAX_NAME_LEN];
value_t values[fields_num];
- size_t i;
ssnprintf (plugin_instance, sizeof (plugin_instance), "v%i%s",
nfs_version, instance);
- for (i = 0; i < fields_num; i++)
+ for (size_t i = 0; i < fields_num; i++)
(void) parse_value (fields[i], &values[i], DS_TYPE_DERIVE);
nfs_procedures_submit (plugin_instance, proc_names, values,
{
char plugin_instance[DATA_MAX_NAME_LEN];
value_t values[proc_names_num];
- size_t i;
if (ksp == NULL)
return (EINVAL);
nfs_version, inst);
kstat_read(kc, ksp, NULL);
- for (i = 0; i < proc_names_num; i++)
+ for (size_t i = 0; i < proc_names_num; i++)
{
/* The name passed to kstat_data_lookup() doesn't have the
* "const" modifier, so we need to copy the name here. */
static int nginx_read (void)
{
- int i;
-
char *ptr;
char *lines[16];
int lines_num = 0;
* 16630948 16630948 31070465
* Reading: 6 Writing: 179 Waiting: 106
*/
- for (i = 0; i < lines_num; i++)
+ for (int i = 0; i < lines_num; i++)
{
fields_num = strsplit (lines[i], fields,
(sizeof (fields) / sizeof (fields[0])));
static int c_notify_config (oconfig_item_t *ci)
{
- int i = 0;
-
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (0 == strcasecmp (c->key, "OkayTimeout"))
static int authinteract (auth_client_request_t request, char **result,
int fields, void __attribute__((unused)) *arg)
{
- int i;
- for (i = 0; i < fields; i++)
+ for (int i = 0; i < fields; i++)
{
if (request[i].flags & AUTH_USER)
result[i] = smtp_user;
static int nagios_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
const char *port;
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
if (sock_descr >= 0)
return (-1);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
/* create our socket descriptor */
if ((sock_descr = socket (ai_ptr->ai_family,
struct resp_pkt res;
int status;
int done;
- int i;
char *items;
size_t items_num;
items_num += pkt_item_num;
*res_data = items;
- for (i = 0; i < pkt_item_num; i++)
+ for (int i = 0; i < pkt_item_num; i++)
{
/* dst: There are already `*res_items' items with
* res_item_size bytes each in in `*res_data'. Set
gauge_t offset_error;
int status;
- int i;
/* On Linux, if the STA_NANO bit is set in ik->status, then ik->offset
* is is nanoseconds, otherwise it's microseconds. */
return (-1);
}
- for (i = 0; i < ps_num; i++)
+ for (int i = 0; i < ps_num; i++)
{
struct info_peer_summary *ptr;
double offset;
static int nut_read (void)
{
- nut_ups_t *ups;
int success = 0;
pthread_mutex_lock (&read_lock);
if (success != 0)
return (0);
- for (ups = upslist_head; ups != NULL; ups = ups->next)
+ for (nut_ups_t *ups = upslist_head; ups != NULL; ups = ups->next)
if (nut_read_one (ups) == 0)
success++;
static FILE *olsrd_connect (void) /* {{{ */
{
- struct addrinfo *ai_list, *ai_ptr;
+ struct addrinfo *ai_list;
int ai_return;
FILE *fh;
}
fh = NULL;
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
int fd;
int status;
value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
int success = 0;
- size_t i;
if (sensor_list != NULL)
{
sstrncpy (vl.plugin, "onewire", sizeof (vl.plugin));
sstrncpy (vl.plugin_instance, name, sizeof (vl.plugin_instance));
- for (i = 0; i < family_info->features_num; i++)
+ for (size_t i = 0; i < family_info->features_num; i++)
{
char *buffer;
size_t buffer_size;
static int cldap_read_host (user_data_t *ud) /* {{{ */
{
cldap_t *st;
- LDAPMessage *e, *result;
+ LDAPMessage *result;
char *dn;
int rc;
int status;
return (-1);
}
- for (e = ldap_first_entry (st->ld, result); e != NULL;
+ for (LDAPMessage *e = ldap_first_entry (st->ld, result); e != NULL;
e = ldap_next_entry (st->ld, e))
{
if ((dn = ldap_get_dn (st->ld, e)) != NULL)
static int cldap_config_add (oconfig_item_t *ci) /* {{{ */
{
cldap_t *st;
- int i;
int status;
st = calloc (1, sizeof (*st));
st->verifyhost = 1;
st->version = LDAP_VERSION3;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int cldap_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
int status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int cldap_shutdown (void) /* {{{ */
{
- size_t i;
-
- for (i = 0; i < databases_num; i++)
+ for (size_t i = 0; i < databases_num; i++)
if (databases[i]->ld != NULL)
ldap_unbind_ext_s (databases[i]->ld, NULL, NULL);
sfree (databases);
static int openvpn_read (void)
{
FILE *fh;
- int i, read;
+ int read;
read = 0;
/* call the right read function for every status entry in the list */
- for (i = 0; i < vpn_num; i++)
+ for (int i = 0; i < vpn_num; i++)
{
int vpn_read = 0;
if (strcasecmp ("StatusFile", key) == 0)
{
char *status_file, *status_name, *filename;
- int status_version, i;
+ int status_version;
vpn_status_t *temp;
/* try to detect the status file format */
}
/* scan the list looking for a clone */
- for (i = 0; i < vpn_num; i++)
+ for (int i = 0; i < vpn_num; i++)
{
if (strcasecmp (vpn_list[i]->name, status_name) == 0)
{
/* shutdown callback */
static int openvpn_shutdown (void)
{
- int i;
-
- for (i = 0; i < vpn_num; i++)
+ for (int i = 0; i < vpn_num; i++)
{
sfree (vpn_list[i]->file);
sfree (vpn_list[i]);
char buffer[2048];
sb4 error_code;
int status;
- unsigned int record_number;
if (db_name == NULL)
db_name = "(none)";
/* An operation may cause / return multiple errors. Loop until we have
* handled all errors available (with a fail-save limit of 16). */
- for (record_number = 1; record_number <= 16; record_number++)
+ for (unsigned int record_number = 1; record_number <= 16; record_number++)
{
memset (buffer, 0, sizeof (buffer));
error_code = -1;
static void o_database_free (o_database_t *db) /* {{{ */
{
- size_t i;
-
if (db == NULL)
return;
sfree (db->queries);
if (db->q_prep_areas != NULL)
- for (i = 0; i < db->queries_num; ++i)
+ for (size_t i = 0; i < db->queries_num; ++i)
udb_query_delete_preparation_area (db->q_prep_areas[i]);
free (db->q_prep_areas);
{
o_database_t *db;
int status;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING))
}
/* Fill the `o_database_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
break;
}
- for (i = 0; i < db->queries_num; ++i)
+ for (int i = 0; i < db->queries_num; ++i)
{
db->q_prep_areas[i]
= udb_query_allocate_preparation_area (db->queries[i]);
static int o_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Query", child->key) == 0)
OCIDefine **oci_defines;
int status;
- size_t i;
oci_statement = udb_query_get_user_data (q);
ALLOC_OR_FAIL (column_names, column_num * sizeof (char *));
ALLOC_OR_FAIL (column_names[0], column_num * DATA_MAX_NAME_LEN
* sizeof (char));
- for (i = 1; i < column_num; i++)
+ for (size_t i = 1; i < column_num; i++)
column_names[i] = column_names[i - 1] + DATA_MAX_NAME_LEN;
ALLOC_OR_FAIL (column_values, column_num * sizeof (char *));
ALLOC_OR_FAIL (column_values[0], column_num * DATA_MAX_NAME_LEN
* sizeof (char));
- for (i = 1; i < column_num; i++)
+ for (size_t i = 1; i < column_num; i++)
column_values[i] = column_values[i - 1] + DATA_MAX_NAME_LEN;
ALLOC_OR_FAIL (oci_defines, column_num * sizeof (OCIDefine *));
/* ``Define'' the returned data, i. e. bind the columns to the buffers
* allocated above. */
- for (i = 0; i < column_num; i++) /* {{{ */
+ for (size_t i = 0; i < column_num; i++) /* {{{ */
{
char *column_name;
ub4 column_name_length;
static int o_read_database (o_database_t *db) /* {{{ */
{
- size_t i;
int status;
if (db->oci_service_context != NULL)
DEBUG ("oracle plugin: o_read_database: db->connect_id = %s; db->oci_service_context = %p;",
db->connect_id, db->oci_service_context);
- for (i = 0; i < db->queries_num; i++)
+ for (size_t i = 0; i < db->queries_num; i++)
o_read_database_query (db, db->queries[i], db->q_prep_areas[i]);
return (0);
static size_t av2value (pTHX_ char *name, AV *array, value_t *value, size_t array_len)
{
const data_set_t *ds;
- size_t i;
if ((NULL == name) || (NULL == array) || (NULL == value) || (array_len == 0))
return 0;
name, array_len, ds->ds_num);
}
- for (i = 0; i < ds->ds_num; ++i) {
+ for (size_t i = 0; i < ds->ds_num; ++i) {
SV **tmp = av_fetch (array, i, 0);
if (NULL != tmp) {
static int av2data_set (pTHX_ AV *array, char *name, data_set_t *ds)
{
- int len, i;
+ int len;
if ((NULL == array) || (NULL == name) || (NULL == ds))
return -1;
ds->ds = smalloc ((len + 1) * sizeof (*ds->ds));
ds->ds_num = len + 1;
- for (i = 0; i <= len; ++i) {
+ for (int i = 0; i <= len; ++i) {
SV **elem = av_fetch (array, i, 0);
if (NULL == elem) {
notification_meta_t **m = meta;
int len = av_len (array);
- int i;
- for (i = 0; i <= len; ++i) {
+ for (int i = 0; i <= len; ++i) {
SV **tmp = av_fetch (array, i, 0);
HV *hash;
static int data_set2av (pTHX_ data_set_t *ds, AV *array)
{
- size_t i;
-
if ((NULL == ds) || (NULL == array))
return -1;
av_extend (array, ds->ds_num);
- for (i = 0; i < ds->ds_num; ++i) {
+ for (size_t i = 0; i < ds->ds_num; ++i) {
HV *source = newHV ();
if (NULL == hv_store (source, "name", 4,
static int notification_meta2av (pTHX_ notification_meta_t *meta, AV *array)
{
int meta_num = 0;
- int i;
while (meta) {
++meta_num;
av_extend (array, meta_num);
- for (i = 0; NULL != meta; meta = meta->next, ++i) {
+ for (int i = 0; NULL != meta; meta = meta->next, ++i) {
HV *m = newHV ();
SV *value;
static int oconfig_item2hv (pTHX_ oconfig_item_t *ci, HV *hash)
{
- int i;
-
AV *values;
AV *children;
return -1;
}
- for (i = 0; i < ci->values_num; ++i) {
+ for (int i = 0; i < ci->values_num; ++i) {
SV *value;
switch (ci->values[i].type) {
return -1;
}
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
HV *child = newHV ();
if (0 != oconfig_item2hv (aTHX_ ci->children + i, child)) {
SV *tmp = NULL;
char *file = __FILE__;
- int i = 0;
-
dXSUB_SYS;
/* enable usage of Perl modules using shared libraries */
newXS ("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
/* register API */
- for (i = 0; NULL != api[i].f; ++i)
+ for (int i = 0; NULL != api[i].f; ++i)
newXS (api[i].name, api[i].f, file);
stash = gv_stashpv ("Collectd", 1);
/* export "constants" */
- for (i = 0; '\0' != constants[i].name[0]; ++i)
+ for (int i = 0; '\0' != constants[i].name[0]; ++i)
newCONSTSUB (stash, constants[i].name, newSViv (constants[i].value));
/* export global variables
* accessing any such variable (this is basically the same as using
* tie() in Perl) */
/* global strings */
- for (i = 0; '\0' != g_strings[i].name[0]; ++i) {
+ for (int i = 0; '\0' != g_strings[i].name[0]; ++i) {
tmp = get_sv (g_strings[i].name, 1);
sv_magicext (tmp, NULL, PERL_MAGIC_ext, &g_pv_vtbl,
g_strings[i].var, 0);
log_info ("Initializing Perl interpreter...");
#if COLLECT_DEBUG
{
- int i = 0;
-
- for (i = 0; i < argc; ++i)
+ for (int i = 0; i < argc; ++i)
log_debug ("argv[%i] = \"%s\"", i, argv[i]);
}
#endif /* COLLECT_DEBUG */
static int perl_config (oconfig_item_t *ci)
{
int status = 0;
- int i = 0;
dTHXa (NULL);
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
int current_status = 0;
struct pf_status state;
int fd;
int status;
- int i;
fd = open (pf_device, O_RDONLY);
if (fd < 0)
return (-1);
}
- for (i = 0; i < PFRES_MAX; i++)
+ for (int i = 0; i < PFRES_MAX; i++)
pf_submit ("pf_counters", pf_reasons[i], state.counters[i],
/* is gauge = */ 0);
- for (i = 0; i < LCNT_MAX; i++)
+ for (int i = 0; i < LCNT_MAX; i++)
pf_submit ("pf_limits", pf_lcounters[i], state.lcounters[i],
/* is gauge = */ 0);
- for (i = 0; i < FCNT_MAX; i++)
+ for (int i = 0; i < FCNT_MAX; i++)
pf_submit ("pf_state", pf_fcounters[i], state.fcounters[i],
/* is gauge = */ 0);
- for (i = 0; i < SCNT_MAX; i++)
+ for (int i = 0; i < SCNT_MAX; i++)
pf_submit ("pf_source", pf_scounters[i], state.scounters[i],
/* is gauge = */ 0);
static void service_process_request (Pinba__Request *request) /* {{{ */
{
- unsigned int i;
-
pthread_mutex_lock (&stat_nodes_lock);
- for (i = 0; i < stat_nodes_num; i++)
+ for (unsigned int i = 0; i < stat_nodes_num; i++)
{
if ((stat_nodes[i].host != NULL)
&& (strcmp (request->hostname, stat_nodes[i].host) != 0))
{
pinba_socket_t *s;
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
if (node == NULL)
return (NULL);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
status = pb_add_socket (s, ai_ptr);
if (status != 0)
static void pinba_socket_free (pinba_socket_t *socket) /* {{{ */
{
- nfds_t i;
-
if (!socket)
return;
- for (i = 0; i < socket->fd_num; i++)
+ for (nfds_t i = 0; i < socket->fd_num; i++)
{
if (socket->fd[i].fd < 0)
continue;
while (!collector_thread_do_shutdown)
{
int status;
- nfds_t i;
if (s->fd_num < 1)
break;
return (-1);
}
- for (i = 0; i < s->fd_num; i++)
+ for (nfds_t i = 0; i < s->fd_num; i++)
{
if (s->fd[i].revents & (POLLERR | POLLHUP | POLLNVAL))
{
char *server = NULL;
char *script = NULL;
int status;
- int i;
status = cf_util_get_string (ci, &name);
if (status != 0)
return (status);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int plugin_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
/* The lock should not be necessary in the config callback, but let's be
* sure.. */
pthread_mutex_lock (&stat_nodes_lock);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int ping_dispatch_all (pingobj_t *pingobj) /* {{{ */
{
- pingobj_iter_t *iter;
hostlist_t *hl;
int status;
- for (iter = ping_iterator_get (pingobj);
+ for (pingobj_iter_t *iter = ping_iterator_get (pingobj);
iter != NULL;
iter = ping_iterator_next (iter))
{ /* {{{ */
struct timespec ts_wait;
struct timespec ts_int;
- hostlist_t *hl;
int count;
c_complain_t complaint = C_COMPLAIN_INIT_STATIC;
/* Add all the hosts to the ping object. */
count = 0;
- for (hl = hostlist_head; hl != NULL; hl = hl->next)
+ for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next)
{
int tmp_status;
tmp_status = ping_host_add (pingobj, hl->host);
/* Max IP packet size - (IPv6 + ICMP) = 65535 - (40 + 8) = 65487 */
if (size <= 65487)
{
- size_t i;
-
sfree (ping_data);
ping_data = malloc (size + 1);
if (ping_data == NULL)
* Optimally we would follow the ping(1) behaviour, but we
* cannot use byte 00 or start data payload at exactly same
* location, due to oping library limitations. */
- for (i = 0; i < size; i++) /* {{{ */
+ for (size_t i = 0; i < size; i++) /* {{{ */
{
/* This restricts data pattern to be only composed of easily
* printable characters, and not NUL character. */
static int ping_read (void) /* {{{ */
{
- hostlist_t *hl;
-
if (ping_thread_error != 0)
{
ERROR ("ping plugin: The ping thread had a problem. Restarting it.");
stop_thread ();
- for (hl = hostlist_head; hl != NULL; hl = hl->next)
+ for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next)
{
hl->pkg_sent = 0;
hl->pkg_recv = 0;
return (-1);
} /* if (ping_thread_error != 0) */
- for (hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
+ for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
{
uint32_t pkg_sent;
uint32_t pkg_recv;
static void c_psql_database_delete (void *data)
{
- size_t i;
-
c_psql_database_t *db = data;
--db->ref_cnt;
db->conn = NULL;
if (db->q_prep_areas)
- for (i = 0; i < db->queries_num; ++i)
+ for (size_t i = 0; i < db->queries_num; ++i)
udb_query_delete_preparation_area (db->q_prep_areas[i]);
free (db->q_prep_areas);
{
const char *params[db->max_params_num];
char interval[64];
- int i;
if ((data == NULL) || (data->params_num == 0))
return (c_psql_exec_query_noparams (db, q));
assert (db->max_params_num >= data->params_num);
- for (i = 0; i < data->params_num; ++i) {
+ for (int i = 0; i < data->params_num; ++i) {
switch (data->params[i]) {
case C_PSQL_PARAM_HOST:
params[i] = C_PSQL_IS_UNIX_DOMAIN_SOCKET (db->host)
int rows_num;
int status;
- int row, col;
/* The user data may hold parameter information, but may be NULL. */
data = udb_query_get_user_data (q);
BAIL_OUT (-1);
}
- for (col = 0; col < column_num; ++col) {
+ for (int col = 0; col < column_num; ++col) {
/* Pointers returned by `PQfname' are freed by `PQclear' via
* `BAIL_OUT'. */
column_names[col] = PQfname (res, col);
BAIL_OUT (-1);
}
- for (row = 0; row < rows_num; ++row) {
+ for (int row = 0; row < rows_num; ++row) {
+ int col;
for (col = 0; col < column_num; ++col) {
/* Pointers returned by `PQgetvalue' are freed by `PQclear' via
* `BAIL_OUT'. */
c_psql_database_t *db;
int success = 0;
- size_t i;
if ((ud == NULL) || (ud->data == NULL)) {
log_err ("c_psql_read: Invalid user data.");
return -1;
}
- for (i = 0; i < db->queries_num; ++i)
+ for (size_t i = 0; i < db->queries_num; ++i)
{
udb_query_preparation_area_t *prep_area;
udb_query_t *q;
{
char *str_ptr;
size_t str_len;
- size_t i;
str_ptr = string;
str_len = string_len;
- for (i = 0; i < ds->ds_num; ++i) {
+ for (size_t i = 0; i < ds->ds_num; ++i) {
int status = ssnprintf (str_ptr, str_len, ",'%s'", ds->ds[i].name);
if (status < 1)
{
char *str_ptr;
size_t str_len;
- size_t i;
str_ptr = string;
str_len = string_len;
- for (i = 0; i < ds->ds_num; ++i) {
+ for (size_t i = 0; i < ds->ds_num; ++i) {
int status;
if (store_rates)
size_t str_len;
gauge_t *rates = NULL;
- size_t i;
str_ptr = string;
str_len = string_len;
- for (i = 0; i < vl->values_len; ++i) {
+ for (size_t i = 0; i < vl->values_len; ++i) {
int status = 0;
if ((ds->ds[i].type != DS_TYPE_GAUGE)
const char *params[9];
int success = 0;
- size_t i;
if ((ud == NULL) || (ud->data == NULL)) {
log_err ("c_psql_write: Invalid user data.");
&& (db->next_commit == 0))
c_psql_begin (db);
- for (i = 0; i < db->writers_num; ++i) {
+ for (size_t i = 0; i < db->writers_num; ++i) {
c_psql_writer_t *writer;
PGresult *res;
{
c_psql_database_t **dbs = databases;
size_t dbs_num = databases_num;
- size_t i;
if ((ud != NULL) && (ud->data != NULL)) {
dbs = (void *)&ud->data;
dbs_num = 1;
}
- for (i = 0; i < dbs_num; ++i) {
+ for (size_t i = 0; i < dbs_num; ++i) {
c_psql_database_t *db = dbs[i];
/* don't commit if the timeout is larger than the regular commit
static int c_psql_shutdown (void)
{
- size_t i = 0;
-
_Bool had_flush = 0;
plugin_unregister_read_group ("postgresql");
- for (i = 0; i < databases_num; ++i) {
+ for (size_t i = 0; i < databases_num; ++i) {
c_psql_database_t *db = databases[i];
if (db->writers_num > 0) {
c_psql_writer_t *tmp;
int status = 0;
- int i;
if ((ci->values_num != 1)
|| (ci->values[0].type != OCONFIG_TYPE_STRING)) {
writer->statement = NULL;
writer->store_rates = 1;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (strcasecmp ("Statement", c->key) == 0)
static _Bool have_flush = 0;
- int i;
-
if ((1 != ci->values_num)
|| (OCONFIG_TYPE_STRING != ci->values[0].type)) {
log_err ("<Database> expects a single string argument.");
if (db == NULL)
return -1;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (0 == strcasecmp (c->key, "Host"))
/* If no `Query' options were given, add the default queries.. */
if ((db->queries_num == 0) && (db->writers_num == 0)){
- for (i = 0; i < def_queries_num; i++)
+ for (int i = 0; i < def_queries_num; i++)
udb_query_pick_from_list_by_name (def_queries[i],
queries, queries_num,
&db->queries, &db->queries_num);
}
}
- for (i = 0; (size_t)i < db->queries_num; ++i) {
+ for (int i = 0; (size_t)i < db->queries_num; ++i) {
c_psql_user_data_t *data;
data = udb_query_get_user_data (db->queries[i]);
if ((data != NULL) && (data->params_num > db->max_params_num))
{
static int have_def_config = 0;
- int i;
-
if (0 == have_def_config) {
oconfig_item_t *c;
"any queries - please check your installation.");
}
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (0 == strcasecmp (c->key, "Query"))
saveptr = NULL;
while ((key = strtok_r (dummy, ",", &saveptr)) != NULL)
{
- int i;
-
dummy = NULL;
value = strchr (key, '=');
continue;
/* Check if this item was requested. */
+ int i;
for (i = 0; i < fields_num; i++)
if (strcasecmp (key, fields[i]) == 0)
break;
static int powerdns_config_add_collect (list_item_t *li, /* {{{ */
oconfig_item_t *ci)
{
- int i;
char **temp;
if (ci->values_num < 1)
return (-1);
}
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
if (ci->values[i].type != OCONFIG_TYPE_STRING)
{
WARNING ("powerdns plugin: Only string arguments are allowed to "
}
li->fields = temp;
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
li->fields[li->fields_num] = strdup (ci->values[i].value.string);
if (li->fields[li->fields_num] == NULL)
list_item_t *item;
int status;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
}
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int powerdns_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
DEBUG ("powerdns plugin: powerdns_config (ci = %p);", (void *) ci);
if (list == NULL)
}
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int powerdns_read (void)
{
- llentry_t *e;
-
- for (e = llist_head (list); e != NULL; e = e->next)
+ for (llentry_t *e = llist_head (list); e != NULL; e = e->next)
{
list_item_t *item = e->value;
item->func (item);
static int powerdns_shutdown (void)
{
- llentry_t *e;
-
if (list == NULL)
return (0);
- for (e = llist_head (list); e != NULL; e = e->next)
+ for (llentry_t *e = llist_head (list); e != NULL; e = e->next)
{
list_item_t *item = (list_item_t *) e->value;
e->value = NULL;
/* add process entry to 'instances' of process 'name' (or refresh it) */
static void ps_list_add (const char *name, const char *cmdline, procstat_entry_t *entry)
{
- procstat_t *ps;
procstat_entry_t *pse;
if (entry->id == 0)
return;
- for (ps = list_head_g; ps != NULL; ps = ps->next)
+ for (procstat_t *ps = list_head_g; ps != NULL; ps = ps->next)
{
_Bool want_init;
/* remove old entries from instances of processes in list_head_g */
static void ps_list_reset (void)
{
- procstat_t *ps;
procstat_entry_t *pse;
procstat_entry_t *pse_prev;
- for (ps = list_head_g; ps != NULL; ps = ps->next)
+ for (procstat_t *ps = list_head_g; ps != NULL; ps = ps->next)
{
ps->num_proc = 0;
ps->num_lwp = 0;
/* put all pre-defined 'Process' names from config to list_head_g tree */
static int ps_config (oconfig_item_t *ci)
{
- int i;
-
#if KERNEL_LINUX
const size_t max_procname_len = 15;
#elif KERNEL_SOLARIS || KERNEL_FREEBSD
const size_t max_procname_len = MAXCOMLEN -1;
#endif
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (strcasecmp (c->key, "Process") == 0)
static int read_fork_rate (void)
{
extern kstat_ctl_t *kc;
- kstat_t *ksp_chain = NULL;
derive_t result = 0;
if (kc == NULL)
return (-1);
- for (ksp_chain = kc->kc_chain;
+ for (kstat_t *ksp_chain = kc->kc_chain;
ksp_chain != NULL;
ksp_chain = ksp_chain->ks_next)
{
#if HAVE_THREAD_INFO
kern_return_t status;
- int pset;
processor_set_t port_pset_priv;
- int task;
task_array_t task_list;
mach_msg_type_number_t task_list_len;
int task_pid;
char task_name[MAXCOMLEN + 1];
- int thread;
thread_act_array_t thread_list;
mach_msg_type_number_t thread_list_len;
thread_basic_info_data_t thread_data;
* Tasks are assigned to sets of processors, so that's where you go to
* get a list.
*/
- for (pset = 0; pset < pset_list_len; pset++)
+ for (int pset = 0; pset < pset_list_len; pset++)
{
if ((status = host_processor_set_priv (port_host_self,
pset_list[pset],
continue;
}
- for (task = 0; task < task_list_len; task++)
+ for (int task = 0; task < task_list_len; task++)
{
ps = NULL;
if (mach_get_task_name (task_list[task],
continue; /* with next task_list */
}
- for (thread = 0; thread < thread_list_len; thread++)
+ for (int thread = 0; thread < thread_list_len; thread++)
{
thread_data_len = THREAD_BASIC_INFO_COUNT;
status = thread_info (thread_list[thread],
procstat_entry_t pse;
char state;
- procstat_t *ps_ptr;
-
running = sleeping = zombies = stopped = paging = blocked = 0;
ps_list_reset ();
ps_submit_state ("paging", paging);
ps_submit_state ("blocked", blocked);
- for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
+ for (procstat_t *ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
ps_submit_proc_list (ps_ptr);
read_fork_rate();
struct kinfo_proc *procs; /* array of processes */
struct kinfo_proc *proc_ptr = NULL;
int count; /* returns number of processes */
- int i;
- procstat_t *ps_ptr;
procstat_entry_t pse;
ps_list_reset ();
}
/* Iterate through the processes in kinfo_proc */
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
{
/* Create only one process list entry per _process_, i.e.
* filter out threads (duplicate PID entries). */
ps_submit_state ("idle", idle);
ps_submit_state ("wait", wait);
- for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
+ for (procstat_t *ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
ps_submit_proc_list (ps_ptr);
/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */
struct kinfo_proc *procs; /* array of processes */
struct kinfo_proc *proc_ptr = NULL;
int count; /* returns number of processes */
- int i;
- procstat_t *ps_ptr;
procstat_entry_t pse;
ps_list_reset ();
}
/* Iterate through the processes in kinfo_proc */
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
{
/* Create only one process list entry per _process_, i.e.
* filter out threads (duplicate PID entries). */
ps_submit_state ("idle", idle);
ps_submit_state ("dead", dead);
- for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
+ for (procstat_t *ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
ps_submit_proc_list (ps_ptr);
/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_OPENBSD */
pid_t pindex = 0;
int nprocs;
- procstat_t *ps;
procstat_entry_t pse;
ps_list_reset ();
/* fdsinfo = */ NULL, sizeof(struct fdsinfo64),
&pindex, MAXPROCENTRY)) > 0)
{
- int i;
-
- for (i = 0; i < nprocs; i++)
+ for (int i = 0; i < nprocs; i++)
{
tid64_t thindex;
int nthreads;
ps_submit_state ("paging", paging);
ps_submit_state ("blocked", blocked);
- for (ps = list_head_g; ps != NULL; ps = ps->next)
+ for (procstat_t *ps = list_head_g; ps != NULL; ps = ps->next)
ps_submit_proc_list (ps);
/* #endif HAVE_PROCINFO_H */
DIR *proc;
int status;
- procstat_t *ps_ptr;
char state;
char cmdline[PRARGSZ];
ps_submit_state ("system", system);
ps_submit_state ("orphan", orphan);
- for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
+ for (procstat_t *ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
ps_submit_proc_list (ps_ptr);
read_fork_rate();
}
void cpy_log_exception(const char *context) {
- int l = 0, i;
+ int l = 0;
const char *typename = NULL, *message = NULL;
PyObject *type, *value, *traceback, *tn, *m, *list;
if (list)
l = PyObject_Length(list);
- for (i = 0; i < l; ++i) {
+ for (int i = 0; i < l; ++i) {
PyObject *line;
char const *msg;
char *cpy;
}
static int cpy_write_callback(const data_set_t *ds, const value_list_t *value_list, user_data_t *data) {
- size_t i;
cpy_callback_t *c = data->data;
PyObject *ret, *list, *temp, *dict = NULL;
Values *v;
cpy_log_exception("write callback");
CPY_RETURN_FROM_THREADS 0;
}
- for (i = 0; i < value_list->values_len; ++i) {
+ for (size_t i = 0; i < value_list->values_len; ++i) {
if (ds->ds[i].type == DS_TYPE_COUNTER) {
PyList_SetItem(list, i, PyLong_FromUnsignedLongLong(value_list->values[i].counter));
} else if (ds->ds[i].type == DS_TYPE_GAUGE) {
meta_data_t *meta = value_list->meta;
num = meta_data_toc(meta, &table);
- for (i = 0; i < num; ++i) {
+ for (size_t i = 0; i < num; ++i) {
int type;
char *string;
int64_t si;
}
static PyObject *cpy_get_dataset(PyObject *self, PyObject *args) {
- size_t i;
char *name;
const data_set_t *ds;
PyObject *list, *tuple;
return NULL;
}
list = PyList_New(ds->ds_num); /* New reference. */
- for (i = 0; i < ds->ds_num; ++i) {
+ for (size_t i = 0; i < ds->ds_num; ++i) {
tuple = PyTuple_New(4);
PyTuple_SET_ITEM(tuple, 0, cpy_string_to_unicode_or_bytes(ds->ds[i].name));
PyTuple_SET_ITEM(tuple, 1, cpy_string_to_unicode_or_bytes(DS_TYPE_TO_STRING(ds->ds[i].type)));
};
static int cpy_shutdown(void) {
- cpy_callback_t *c;
PyObject *ret;
/* This can happen if the module was loaded but not configured. */
if (state != NULL)
PyEval_RestoreThread(state);
- for (c = cpy_shutdown_callbacks; c; c = c->next) {
+ for (cpy_callback_t *c = cpy_shutdown_callbacks; c; c = c->next) {
ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
if (ret == NULL)
cpy_log_exception("shutdown callback");
}
static int cpy_init(void) {
- cpy_callback_t *c;
PyObject *ret;
static pthread_t thread;
sigset_t sigset;
}
PyEval_InitThreads();
/* Now it's finally OK to use python threads. */
- for (c = cpy_init_callbacks; c; c = c->next) {
+ for (cpy_callback_t *c = cpy_init_callbacks; c; c = c->next) {
ret = PyObject_CallFunctionObjArgs(c->callback, c->data, (void *) 0); /* New reference. */
if (ret == NULL)
cpy_log_exception("init callback");
}
static PyObject *cpy_oconfig_to_pyconfig(oconfig_item_t *ci, PyObject *parent) {
- int i;
PyObject *item, *values, *children, *tmp;
if (parent == NULL)
parent = Py_None;
values = PyTuple_New(ci->values_num); /* New reference. */
- for (i = 0; i < ci->values_num; ++i) {
+ for (int i = 0; i < ci->values_num; ++i) {
if (ci->values[i].type == OCONFIG_TYPE_STRING) {
PyTuple_SET_ITEM(values, i, cpy_string_to_unicode_or_bytes(ci->values[i].value.string));
} else if (ci->values[i].type == OCONFIG_TYPE_NUMBER) {
if (item == NULL)
return NULL;
children = PyTuple_New(ci->children_num); /* New reference. */
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
PyTuple_SET_ITEM(children, i, cpy_oconfig_to_pyconfig(ci->children + i, item));
}
tmp = ((Config *) item)->children;
}
static int cpy_config(oconfig_item_t *ci) {
- int i;
PyObject *tb;
/* Ok in theory we shouldn't do initialization at this point
if (!Py_IsInitialized() && cpy_init_python()) return 1;
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *item = ci->children + i;
if (strcasecmp(item->key, "Interactive") == 0) {
}
static meta_data_t *cpy_build_meta(PyObject *meta) {
- int i, s;
+ int s;
meta_data_t *m = NULL;
PyObject *l;
}
m = meta_data_create();
- for (i = 0; i < s; ++i) {
+ for (int i = 0; i < s; ++i) {
const char *string, *keystring;
PyObject *key, *value, *item, *tmp;
static PyObject *Values_dispatch(Values *self, PyObject *args, PyObject *kwds) {
int ret;
const data_set_t *ds;
- size_t size, i;
+ size_t size;
value_t *value;
value_list_t value_list = VALUE_LIST_INIT;
PyObject *values = self->values, *meta = self->meta;
return NULL;
}
value = calloc(size, sizeof(*value));
- for (i = 0; i < size; ++i) {
+ for (size_t i = 0; i < size; ++i) {
PyObject *item, *num;
item = PySequence_Fast_GET_ITEM(values, (int) i); /* Borrowed reference. */
if (ds->ds->type == DS_TYPE_COUNTER) {
static PyObject *Values_write(Values *self, PyObject *args, PyObject *kwds) {
int ret;
const data_set_t *ds;
- size_t size, i;
+ size_t size;
value_t *value;
value_list_t value_list = VALUE_LIST_INIT;
PyObject *values = self->values, *meta = self->meta;
return NULL;
}
value = calloc(size, sizeof(*value));
- for (i = 0; i < size; ++i) {
+ for (size_t i = 0; i < size; ++i) {
PyObject *item, *num;
item = PySequence_Fast_GET_ITEM(values, i); /* Borrowed reference. */
if (ds->ds->type == DS_TYPE_COUNTER) {
{
redis_query_t *rq;
int status;
- int i;
rq = calloc(1, sizeof(*rq));
if (rq == NULL) {
(void)sstrncpy(rq->instance, rq->query, sizeof(rq->instance));
replace_special(rq->instance, sizeof(rq->instance));
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *option = ci->children + i;
if (strcasecmp("Type", option->key) == 0) {
static int redis_config_node (oconfig_item_t *ci) /* {{{ */
{
redis_query_t *rq;
- int i;
int status;
int timeout;
if (status != 0)
return (status);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int redis_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int redis_read (void) /* {{{ */
{
- redis_node_t *rn;
- redis_query_t *rq;
-
- for (rn = nodes_head; rn != NULL; rn = rn->next)
+ for (redis_node_t *rn = nodes_head; rn != NULL; rn = rn->next)
{
redisContext *rh;
redisReply *rr;
redis_handle_info (rn->name, rr->str, "total_bytes", "input", "total_net_input_bytes", DS_TYPE_DERIVE);
redis_handle_info (rn->name, rr->str, "total_bytes", "output", "total_net_output_bytes", DS_TYPE_DERIVE);
- for (rq = rn->queries; rq != NULL; rq = rq->next)
+ for (redis_query_t *rq = rn->queries; rq != NULL; rq = rq->next)
redis_handle_query(rh, rn, rq);
redis_fail:
char read_name[128];
user_data_t user_data;
int status;
- int i;
router_data = calloc (1, sizeof (*router_data));
if (router_data == NULL)
router_data->password = NULL;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int cr_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
int offset;
int status;
- size_t i;
time_t t;
assert (0 == strcmp (ds->type, vl->type));
return (-1);
offset = status;
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if ((ds->ds[i].type != DS_TYPE_COUNTER)
&& (ds->ds[i].type != DS_TYPE_GAUGE)
static int rc_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t const *child = ci->children + i;
const char *key = child->key;
{
int status;
rrdc_stats_t *head;
- rrdc_stats_t *ptr;
value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
return (-1);
}
- for (ptr = head; ptr != NULL; ptr = ptr->next)
+ for (rrdc_stats_t *ptr = head; ptr != NULL; ptr = ptr->next)
{
if (ptr->type == RRDC_STATS_TYPE_GAUGE)
values[0].gauge = (gauge_t) ptr->value.gauge;
int offset;
int status;
time_t tt;
- size_t i;
memset (buffer, '\0', buffer_len);
return (-1);
offset = status;
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if ((ds->ds[i].type != DS_TYPE_COUNTER)
&& (ds->ds[i].type != DS_TYPE_GAUGE)
char **values;
int values_num;
int status;
- int i;
values = NULL;
values_num = 0;
values_num, (values_num == 1) ? "" : "s",
queue_entry->filename);
- for (i = 0; i < values_num; i++)
+ for (int i = 0; i < values_num; i++)
{
sfree (values[i]);
}
char *key;
c_avl_iterator_t *iter;
- int i;
DEBUG ("rrdtool plugin: Flushing cache, timeout = %.3f",
CDTIME_T_TO_DOUBLE (timeout));
} /* while (c_avl_iterator_next) */
c_avl_iterator_destroy (iter);
- for (i = 0; i < keys_num; i++)
+ for (int i = 0; i < keys_num; i++)
{
if (c_avl_remove (cache, keys[i], (void *) &key, (void *) &rc) != 0)
{
while (c_avl_pick (cache, &key, &value) == 0)
{
rrd_cache_t *rc;
- int i;
sfree (key);
key = NULL;
if (rc->values_num > 0)
non_empty++;
- for (i = 0; i < rc->values_num; i++)
+ for (int i = 0; i < rc->values_num; i++)
sfree (rc->values[i]);
sfree (rc->values);
sfree (rc);
static int sensors_feature_name_to_type (const char *name)
{
- int i;
-
/* Yes, this is slow, but it's only ever done during initialization, so
* it's a one time cost.. */
- for (i = 0; i < known_features_num; i++)
+ for (int i = 0; i < known_features_num; i++)
if (strcasecmp (known_features[i].label, name) == 0)
return (known_features[i].type);
static void sensors_free_features (void)
{
- featurelist_t *thisft;
featurelist_t *nextft;
if (first_feature == NULL)
sensors_cleanup ();
- for (thisft = first_feature; thisft != NULL; thisft = nextft)
+ for (featurelist_t *thisft = first_feature; thisft != NULL; thisft = nextft)
{
nextft = thisft->next;
sfree (thisft);
static int sensors_read (void)
{
- featurelist_t *fl;
-
if (sensors_load_conf () != 0)
return (-1);
#if SENSORS_API_VERSION < 0x400
- for (fl = first_feature; fl != NULL; fl = fl->next)
+ for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next)
{
double value;
int status;
/* #endif SENSORS_API_VERSION < 0x400 */
#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500)
- for (fl = first_feature; fl != NULL; fl = fl->next)
+ for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next)
{
double value;
int status;
char *fields[16];
int numfields;
- int i;
numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
if (numfields < 6)
continue;
fields[0][len - 1] = 0;
- for (i = 1; i < numfields; i++)
+ for (int i = 1; i < numfields; i++)
{
len = strlen (fields[i]);
if (len < 4)
static int sigrok_config_device(oconfig_item_t *ci)
{
struct config_device *cfdev;
- int i;
if (!(cfdev = calloc(1, sizeof(*cfdev)))) {
ERROR("sigrok plugin: calloc failed.");
}
cfdev->min_dispatch_interval = DEFAULT_MIN_DISPATCH_INTERVAL;
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *item = ci->children + i;
if (!strcasecmp(item->key, "driver"))
cf_util_get_string(item, &cfdev->driver);
static int sigrok_config(oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *item = ci->children + i;
if (strcasecmp("LogLevel", item->key) == 0) {
int status;
{
const struct sr_datafeed_analog *analog;
struct config_device *cfdev;
- GSList *l;
value_t value;
value_list_t vl = VALUE_LIST_INIT;
/* Find this device's configuration. */
cfdev = NULL;
- for (l = config_devices; l; l = l->next) {
+ for (GSList *l = config_devices; l; l = l->next) {
cfdev = l->data;
if (cfdev->sdi == sdi) {
/* Found it. */
{
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++)
+ for (size_t 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];
static int csnmp_config_add_data_values (data_definition_t *dd, oconfig_item_t *ci)
{
- int i;
-
if (ci->values_num < 1)
{
WARNING ("snmp plugin: `Values' needs at least one argument.");
return (-1);
}
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
if (ci->values[i].type != OCONFIG_TYPE_STRING)
{
WARNING ("snmp plugin: `Values' needs only string argument.");
return (-1);
dd->values_len = (size_t) ci->values_num;
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
dd->values[i].oid_len = MAX_OID_LEN;
static int csnmp_config_add_data_blacklist(data_definition_t *dd, oconfig_item_t *ci)
{
- int i;
-
if (ci->values_num < 1)
return (0);
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
if (ci->values[i].type != OCONFIG_TYPE_STRING)
{
dd->ignores_len = 0;
dd->ignores = NULL;
- for (i = 0; i < ci->values_num; ++i)
+ for (int i = 0; i < ci->values_num; ++i)
{
if (strarray_add(&(dd->ignores), &(dd->ignores_len), ci->values[i].value.string) != 0)
{
{
data_definition_t *dd;
int status = 0;
- int i;
dd = calloc (1, sizeof (*dd));
if (dd == NULL)
dd->scale = 1.0;
dd->shift = 0.0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
data_definition_t *data;
data_definition_t **data_list;
int data_list_len;
- int i;
if (ci->values_num < 1)
{
return (-1);
}
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
if (ci->values[i].type != OCONFIG_TYPE_STRING)
{
WARNING ("snmp plugin: All arguments to `Collect' must be strings.");
return (-1);
host->data_list = data_list;
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
for (data = data_head; data != NULL; data = data->next)
if (strcasecmp (ci->values[i].value.string, data->name) == 0)
{
host_definition_t *hd;
int status = 0;
- int i;
/* Registration stuff. */
char cb_name[DATA_MAX_NAME_LEN];
hd->sess_handle = NULL;
hd->interval = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
status = 0;
static int csnmp_config (oconfig_item_t *ci)
{
- int i;
-
call_snmp_init_once ();
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Data", child->key) == 0)
{
char *buffer_ptr;
size_t buffer_free;
- size_t i;
dst[0] = 0;
buffer_ptr = dst;
buffer_free = dst_size;
- for (i = 0; i < vb->val_len; i++)
+ for (size_t i = 0; i < vb->val_len; i++)
{
int status;
{
char *src;
size_t num_chars;
- size_t i;
if (vb->type == ASN_OCTET_STR)
src = (char *) vb->val.string;
if (num_chars > vb->val_len)
num_chars = vb->val_len;
- for (i = 0; i < num_chars; i++)
+ for (size_t i = 0; i < num_chars; i++)
{
/* Check for control characters. */
if ((unsigned char)src[i] < 32)
struct variable_list *vb;
oid_t vb_name;
int status;
- uint32_t i;
uint32_t is_matched;
/* Set vb on the last variable */
csnmp_strvbcopy (il->instance, vb, sizeof (il->instance));
is_matched = 0;
- for (i = 0; i < dd->ignores_len; i++)
+ for (uint32_t i = 0; i < dd->ignores_len; i++)
{
status = fnmatch(dd->ignores[i], il->instance, 0);
if (status == 0)
size_t fds_num = 0;
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
char const *node = (conf_node != NULL) ? conf_node : STATSD_DEFAULT_NODE;
return (status);
}
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
int fd;
struct pollfd *tmp;
struct pollfd *fds = NULL;
size_t fds_num = 0;
int status;
- size_t i;
status = statsd_network_init (&fds, &fds_num);
if (status != 0)
break;
}
- for (i = 0; i < fds_num; i++)
+ for (size_t i = 0; i < fds_num; i++)
{
if ((fds[i].revents & (POLLIN | POLLPRI)) == 0)
continue;
} /* while (!network_thread_shutdown) */
/* Clean up */
- for (i = 0; i < fds_num; i++)
+ for (size_t i = 0; i < fds_num; i++)
close (fds[i].fd);
sfree (fds);
static int statsd_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
values[0].gauge = (gauge_t) metric->value;
else if (metric->type == STATSD_TIMER)
{
- size_t i;
_Bool have_events = (metric->updates_num > 0);
/* Make sure all timer metrics share the *same* timestamp. */
plugin_dispatch_values (&vl);
}
- for (i = 0; i < conf_timer_percentile_num; i++)
+ for (size_t i = 0; i < conf_timer_percentile_num; i++)
{
ssnprintf (vl.type_instance, sizeof (vl.type_instance),
"%s-percentile-%.0f", name, conf_timer_percentile[i]);
char **to_be_deleted = NULL;
size_t to_be_deleted_num = 0;
- size_t i;
pthread_mutex_lock (&metrics_lock);
}
c_avl_iterator_destroy (iter);
- for (i = 0; i < to_be_deleted_num; i++)
+ for (size_t i = 0; i < to_be_deleted_num; i++)
{
int status;
static int swap_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("ReportBytes", child->key) == 0)
char *s_paths;
int swap_num;
int status;
- int i;
gauge_t avail = 0;
gauge_t total = 0;
sfree (s);
return (-1);
}
- for (i = 0; i < swap_num; i++)
+ for (int i = 0; i < swap_num; i++)
s->swt_ent[i].ste_path = s_paths + (i * PATH_MAX);
s->swt_n = swap_num;
/* less elements returned than requested */
swap_num = status;
- for (i = 0; i < swap_num; i++)
+ for (int i = 0; i < swap_num; i++)
{
char path[PATH_MAX];
gauge_t this_total;
struct swapent *swap_entries;
int swap_num;
int status;
- int i;
gauge_t used = 0;
gauge_t total = 0;
/* TODO: Report per-device stats. The path name is available from
* swap_entries[i].se_path */
- for (i = 0; i < swap_num; i++)
+ for (int i = 0; i < swap_num; i++)
{
if ((swap_entries[i].se_flags & SWF_ENABLE) == 0)
continue;
static void tbl_clear (tbl_t *tbl)
{
- size_t i;
-
sfree (tbl->file);
sfree (tbl->sep);
sfree (tbl->instance);
- for (i = 0; i < tbl->results_num; ++i)
+ for (size_t i = 0; i < tbl->results_num; ++i)
tbl_result_clear (tbl->results + i);
sfree (tbl->results);
tbl->results_num = 0;
{
size_t *tmp;
size_t num;
- size_t i;
if (1 > ci->values_num) {
log_err ("\"%s\" expects at least one argument.", name);
}
num = (size_t) ci->values_num;
- for (i = 0; i < num; ++i) {
+ for (size_t i = 0; i < num; ++i) {
if (OCONFIG_TYPE_NUMBER != ci->values[i].type) {
log_err ("\"%s\" expects numerical arguments only.", name);
return 1;
}
*var = tmp;
- for (i = 0; i < num; ++i) {
+ for (size_t i = 0; i < num; ++i) {
(*var)[*len] = (size_t) ci->values[i].value.number;
(*len)++;
}
tbl_result_t *res;
int status = 0;
- int i;
if (0 != ci->values_num) {
log_err ("<Result> does not expect any arguments.");
res = tbl->results + tbl->results_num - 1;
tbl_result_setup (res);
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (0 == strcasecmp (c->key, "Type"))
tbl_t *tbl;
int status = 0;
- size_t i;
if ((1 != ci->values_num)
|| (OCONFIG_TYPE_STRING != ci->values[0].type)) {
tbl = tables + tables_num - 1;
tbl_setup (tbl, ci->values[0].value.string);
- for (i = 0; i < ((size_t) ci->children_num); ++i) {
+ for (size_t i = 0; i < ((size_t) ci->children_num); ++i) {
oconfig_item_t *c = ci->children + i;
if (0 == strcasecmp (c->key, "Separator"))
return status;
}
- for (i = 0; i < tbl->results_num; ++i) {
+ for (size_t i = 0; i < tbl->results_num; ++i) {
tbl_result_t *res = tbl->results + i;
- size_t j;
- for (j = 0; j < res->instances_num; ++j)
+ for (size_t j = 0; j < res->instances_num; ++j)
if (res->instances[j] > tbl->max_colnum)
tbl->max_colnum = res->instances[j];
- for (j = 0; j < res->values_num; ++j)
+ for (size_t j = 0; j < res->values_num; ++j)
if (res->values[j] > tbl->max_colnum)
tbl->max_colnum = res->values[j];
}
static int tbl_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; ++i) {
+ for (int i = 0; i < ci->children_num; ++i) {
oconfig_item_t *c = ci->children + i;
if (0 == strcasecmp (c->key, "Table"))
static int tbl_prepare (tbl_t *tbl)
{
- size_t i;
-
- for (i = 0; i < tbl->results_num; ++i) {
+ for (size_t i = 0; i < tbl->results_num; ++i) {
tbl_result_t *res = tbl->results + i;
res->ds = plugin_get_ds (res->type);
static int tbl_finish (tbl_t *tbl)
{
- size_t i;
-
- for (i = 0; i < tbl->results_num; ++i)
+ for (size_t i = 0; i < tbl->results_num; ++i)
tbl->results[i].ds = NULL;
return 0;
} /* tbl_finish */
value_list_t vl = VALUE_LIST_INIT;
value_t values[res->values_num];
- size_t i;
-
assert (NULL != res->ds);
assert (res->values_num == res->ds->ds_num);
- for (i = 0; i < res->values_num; ++i) {
+ for (size_t i = 0; i < res->values_num; ++i) {
char *value;
assert (res->values[i] < fields_num);
char *instances[res->instances_num];
char instances_str[DATA_MAX_NAME_LEN];
- for (i = 0; i < res->instances_num; ++i) {
+ for (size_t i = 0; i < res->instances_num; ++i) {
assert (res->instances[i] < fields_num);
instances[i] = fields[res->instances[i]];
}
char *fields[tbl->max_colnum + 1];
char *ptr, *saveptr;
- size_t i;
+ size_t i = 0;
- i = 0;
ptr = line;
saveptr = NULL;
while (NULL != (fields[i] = strtok_r (ptr, tbl->sep, &saveptr))) {
static int tbl_read (void)
{
int status = -1;
- size_t i;
if (0 == tables_num)
return 0;
- for (i = 0; i < tables_num; ++i) {
+ for (size_t i = 0; i < tables_num; ++i) {
tbl_t *tbl = tables + i;
if (0 != tbl_prepare (tbl)) {
static int tbl_shutdown (void)
{
- size_t i;
-
- for (i = 0; i < tables_num; ++i)
+ for (size_t i = 0; i < tables_num; ++i)
tbl_clear (&tables[i]);
sfree (tables);
return 0;
{
ctail_config_match_t cm = { 0 };
int status;
- int i;
if (ci->values_num != 0)
{
}
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
cdtime_t interval = 0;
char *plugin_instance = NULL;
int num_matches = 0;
- int i;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
return (-1);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
int status = 0;
static int ctail_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
{
char str[255];
user_data_t ud = { 0 };
- size_t i;
if (tail_match_list_num == 0)
{
return (-1);
}
- for (i = 0; i < tail_match_list_num; i++)
+ for (size_t i = 0; i < tail_match_list_num; i++)
{
ud.data = (void *)tail_match_list[i];
ssnprintf(str, sizeof(str), "tail-%zu", i);
static int ctail_shutdown (void)
{
- size_t i;
-
- for (i = 0; i < tail_match_list_num; i++)
+ for (size_t i = 0; i < tail_match_list_num; i++)
{
tail_match_destroy (tail_match_list[i]);
tail_match_list[i] = NULL;
static int tcsv_config_add_metric(oconfig_item_t *ci){
metric_definition_t *md;
int status;
- int i;
md = calloc(1, sizeof(*md));
if (md == NULL)
return (-1);
}
- for (i = 0; i < ci->children_num; ++i){
+ for (int i = 0; i < ci->children_num; ++i){
oconfig_item_t *option = ci->children + i;
if (strcasecmp("Type", option->key) == 0)
metric_definition_t *metric;
metric_definition_t **metric_list;
size_t metric_list_size;
- int i;
if (ci->values_num < 1) {
WARNING("tail_csv plugin: The `Collect' config option needs at least one argument.");
return (-1);
id->metric_list = metric_list;
- for (i = 0; i < ci->values_num; i++) {
+ for (int i = 0; i < ci->values_num; i++) {
char *metric_name;
if (ci->values[i].type != OCONFIG_TYPE_STRING) {
{
instance_definition_t* id;
int status = 0;
- int i;
/* Registration variables */
char cb_name[DATA_MAX_NAME_LEN];
/* Use default interval. */
id->interval = plugin_get_interval();
- for (i = 0; i < ci->children_num; ++i){
+ for (int i = 0; i < ci->children_num; ++i){
oconfig_item_t *option = ci->children + i;
status = 0;
/* Parse blocks */
static int tcsv_config(oconfig_item_t *ci){
- int i;
- for (i = 0; i < ci->children_num; ++i){
+ for (int i = 0; i < ci->children_num; ++i){
oconfig_item_t *child = ci->children + i;
if (strcasecmp("Metric", child->key) == 0)
tcsv_config_add_metric(child);
# error "kstat_io_t does not have the required members"
#endif
static kstat_io_t kio;
- int i;
if (kc == NULL)
return (-1);
if (numtape <= 0)
return (-1);
- for (i = 0; i < numtape; i++)
+ for (int i = 0; i < numtape; i++)
{
if (kstat_read (kc, ksp[i], &kio) == -1)
continue;
{
tn_data_t *data;
int status;
- int i;
data = calloc (1, sizeof (*data));
if (data == NULL)
data->severity = 0;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
gauge_t *rates;
int rates_failed;
- size_t i;
-
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
return (-EINVAL);
rates_failed = 0;
rates = NULL;
- for (i = 0; i < ds->ds_num; i++)
+
+ for (size_t i = 0; i < ds->ds_num; i++)
{
char template[DATA_MAX_NAME_LEN];
char value_str[DATA_MAX_NAME_LEN];
static int tr_action_invoke (tr_action_t *act_head, /* {{{ */
char *buffer_in, size_t buffer_in_size, int may_be_empty)
{
- tr_action_t *act;
int status;
char buffer[DATA_MAX_NAME_LEN];
regmatch_t matches[8] = { [0] = { 0 } };
DEBUG ("target_replace plugin: tr_action_invoke: <- buffer = %s;", buffer);
- for (act = act_head; act != NULL; act = act->next)
+ for (tr_action_t *act = act_head; act != NULL; act = act->next)
{
char temp[DATA_MAX_NAME_LEN];
char *subst_status;
{
tr_data_t *data;
int status;
- int i;
data = calloc (1, sizeof (*data));
if (data == NULL)
data->type_instance = NULL;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
size_t new_data_sources_num;
char **temp;
- int i;
/* Check number of arbuments. */
if (ci->values_num < 1)
}
/* Check type of arguments */
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
if (ci->values[i].type == OCONFIG_TYPE_STRING)
continue;
data->data_sources = temp;
/* Copy the strings, allocating memory as needed. */
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
size_t j;
if ((data != NULL) && (data->data_sources != NULL))
{
- size_t i;
- for (i = 0; i < data->data_sources_num; i++)
+ for (size_t i = 0; i < data->data_sources_num; i++)
sfree (data->data_sources[i]);
sfree (data->data_sources);
}
{
ts_data_t *data;
int status;
- int i;
data = calloc (1, sizeof (*data));
if (data == NULL)
data->offset = NAN;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
notification_meta_t __attribute__((unused)) **meta, void **user_data)
{
ts_data_t *data;
- size_t i;
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
return (-EINVAL);
return (-EINVAL);
}
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
/* If we've got a list of data sources, is it in the list? */
if (data->data_sources) {
{
ts_data_t *data;
int status;
- int i;
data = calloc (1, sizeof (*data));
if (data == NULL)
data->meta = NULL;
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
{
value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
- int i;
conn_prepare_vl (&vl, values);
ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
"%"PRIu16"-local", pe->port);
- for (i = 1; i <= TCP_STATE_MAX; i++)
+ for (int i = 1; i <= TCP_STATE_MAX; i++)
{
vl.values[0].gauge = pe->count_local[i];
ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
"%"PRIu16"-remote", pe->port);
- for (i = 1; i <= TCP_STATE_MAX; i++)
+ for (int i = 1; i <= TCP_STATE_MAX; i++)
{
vl.values[0].gauge = pe->count_remote[i];
{
value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
- int i;
conn_prepare_vl (&vl, values);
sstrncpy (vl.plugin_instance, "all", sizeof (vl.plugin_instance));
- for (i = 1; i <= TCP_STATE_MAX; i++)
+ for (int i = 1; i <= TCP_STATE_MAX; i++)
{
vl.values[0].gauge = count_total[i];
static void conn_submit_all (void)
{
- port_entry_t *pe;
-
if (port_collect_total)
conn_submit_port_total ();
- for (pe = port_list_head; pe != NULL; pe = pe->next)
+ for (port_entry_t *pe = port_list_head; pe != NULL; pe = pe->next)
conn_submit_port_entry (pe);
} /* void conn_submit_all */
static int conn_read (void)
{
int size;
- int i;
int nconn;
void *data;
struct netinfo_header *header;
nconn = header->size;
conn = (struct netinfo_conn *)(data + sizeof(struct netinfo_header));
- for (i=0; i < nconn; conn++, i++)
+ for (int i = 0; i < nconn; conn++, i++)
{
conn_handle_ports (conn->srcport, conn->dstport, conn->tcp_state);
}
* if it's not already present
*/
struct addrinfo *ai_head;
- struct addrinfo *ai_ptr;
int sd = -1;
int status;
}
/* Try all given hosts until we can connect to one */
- for (ai_ptr = ai_head; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_head; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
/* Create socket */
sd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
* Poll function which collects global and vserver information
* and submits it to collectd
*/
- vserver_list_t *vserver;
int success = 0;
int status;
}
/* Handle vservers */
- for (vserver = server_list; vserver != NULL; vserver = vserver->next)
+ for (vserver_list_t *vserver = server_list; vserver != NULL; vserver = vserver->next)
{
status = tss2_read_vserver (vserver);
if (status == 0)
while (end_flag == 0)
{
ssize_t receive_buffer_length;
- ssize_t i;
/* check for timeout or input error*/
status = select (fd + 1, &input, NULL, NULL, &timeout);
* the beginning of the package has been found. */
escape_flag = 0;
- for (i = 0; i < receive_buffer_length; i++)
+ for (ssize_t i = 0; i < receive_buffer_length; i++)
{
/* Check if previous byte was the escape byte. */
if (escape_flag == 1)
double power;
double voltage;
int status;
- int i;
status = ted_open_device ();
if (status != 0)
power = NAN;
voltage = NAN;
- for (i = 0; i <= conf_retries; i++)
+ for (int i = 0; i <= conf_retries; i++)
{
status = ted_read_value (&power, &voltage);
if (status == 0)
static int ut_config_type (const threshold_t *th_orig, oconfig_item_t *ci)
{
- int i;
threshold_t th;
int status = 0;
th.hysteresis = 0;
th.flags = UT_FLAG_INTERESTING; /* interesting by default */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int ut_config_plugin (const threshold_t *th_orig, oconfig_item_t *ci)
{
- int i;
threshold_t th;
int status = 0;
memcpy (&th, th_orig, sizeof (th));
sstrncpy (th.plugin, ci->values[0].value.string, sizeof (th.plugin));
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
static int ut_config_host (const threshold_t *th_orig, oconfig_item_t *ci)
{
- int i;
threshold_t th;
int status = 0;
memcpy (&th, th_orig, sizeof (th));
sstrncpy (th.host, ci->values[0].value.string, sizeof (th.host));
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
{
gauge_t value;
gauge_t sum;
- size_t i;
sum = 0.0;
- for (i = 0; i < vl->values_len; i++)
+ for (size_t i = 0; i < vl->values_len; i++)
{
if (isnan (values[i]))
continue;
{ /* {{{ */
int ret = -1;
int ds_index = -1;
- size_t i;
gauge_t values_copy[ds->ds_num];
memcpy (values_copy, values, sizeof (values_copy));
}
/* Prepare `sum' and `num'. */
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
if (!isnan (values[i]))
{
num++;
if ((num == 0) /* All data sources are undefined. */
|| (sum == 0.0)) /* Sum is zero, cannot calculate percentage. */
{
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
values_copy[i] = NAN;
}
else /* We can actually calculate the percentage. */
{
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
values_copy[i] = 100.0 * values[i] / sum;
}
} /* if (UT_FLAG_PERCENTAGE) */
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
int status;
static int ut_config (oconfig_item_t *ci)
{ /* {{{ */
- int i;
int status = 0;
int old_size = c_avl_size (threshold_tree);
.flags = UT_FLAG_INTERESTING /* interesting by default */
};
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
{
int retval;
- unsigned int pkg_no, core_no, thread_no;
- for (pkg_no = 0; pkg_no < topology.num_packages; ++pkg_no) {
- for (core_no = 0; core_no < topology.num_cores; ++core_no) {
- for (thread_no = 0; thread_no < topology.num_threads; ++thread_no) {
+ for (unsigned int pkg_no = 0; pkg_no < topology.num_packages; ++pkg_no) {
+ for (unsigned int core_no = 0; core_no < topology.num_cores; ++core_no) {
+ for (unsigned int thread_no = 0; thread_no < topology.num_threads; ++thread_no) {
struct thread_data *t;
struct core_data *c;
struct pkg_data *p;
const struct thread_data *thread_old_base, const struct core_data *core_old_base, const struct pkg_data *pkg_old_base)
{
int retval;
- unsigned int pkg_no, core_no, thread_no;
- for (pkg_no = 0; pkg_no < topology.num_packages; ++pkg_no) {
- for (core_no = 0; core_no < topology.num_cores; ++core_no) {
- for (thread_no = 0; thread_no < topology.num_threads; ++thread_no) {
+ for (unsigned int pkg_no = 0; pkg_no < topology.num_packages; ++pkg_no) {
+ for (unsigned int core_no = 0; core_no < topology.num_cores; ++core_no) {
+ for (unsigned int thread_no = 0; thread_no < topology.num_threads; ++thread_no) {
struct thread_data *t_delta;
const struct thread_data *t_old, *t_new;
struct core_data *c_delta;
static int __attribute__((warn_unused_result))
topology_probe(void)
{
- unsigned int i;
int ret;
unsigned int max_package_id, max_core_id, max_threads;
max_package_id = max_core_id = max_threads = 0;
* For online cpus
* find max_core_id, max_package_id
*/
- for (i = 0; i <= topology.max_cpu_id; ++i) {
+ for (unsigned int i = 0; i <= topology.max_cpu_id; ++i) {
unsigned int num_threads;
struct cpu_topology *cpu = &topology.cpus[i];
static int
allocate_counters(struct thread_data **threads, struct core_data **cores, struct pkg_data **packages)
{
- unsigned int i;
unsigned int total_threads, total_cores;
if ((topology.num_threads == 0)
return -1;
}
- for (i = 0; i < total_threads; ++i)
+ for (unsigned int i = 0; i < total_threads; ++i)
(*threads)[i].cpu_id = topology.max_cpu_id + 1;
total_cores = topology.num_cores * topology.num_packages;
static void
initialize_counters(void)
{
- unsigned int cpu_id;
-
- for (cpu_id = 0; cpu_id <= topology.max_cpu_id; ++cpu_id) {
+ for (unsigned int cpu_id = 0; cpu_id <= topology.max_cpu_id; ++cpu_id) {
if (cpu_is_not_present(cpu_id))
continue;
init_counter(EVEN_COUNTERS, cpu_id);
char **identifiers = NULL;
size_t identifiers_num = 0;
- size_t i;
-
#define PRINT_TO_SOCK(fh, ...) \
do { \
if (fprintf (fh, __VA_ARGS__) < 0) { \
}
} /* while (*buffer != 0) */
- for (i = 0; (i == 0) || (i < plugins_num); i++)
+ for (size_t i = 0; (i == 0) || (i < plugins_num); i++)
{
char *plugin = NULL;
- size_t j;
if (plugins_num != 0)
plugin = plugins[i];
- for (j = 0; (j == 0) || (j < identifiers_num); j++)
+ for (size_t j = 0; (j == 0) || (j < identifiers_num); j++)
{
char *identifier = NULL;
int status;
const data_set_t *ds;
int status;
- size_t i;
if ((fh == NULL) || (buffer == NULL))
return (-1);
print_to_socket (fh, "%zu Value%s found\n", values_num,
(values_num == 1) ? "" : "s");
- for (i = 0; i < values_num; i++)
+ for (size_t i = 0; i < values_num; i++)
{
print_to_socket (fh, "%s=", ds->ds[i].name);
if (isnan (values[i]))
#include "utils_parse_option.h"
#define free_everything_and_return(status) do { \
- size_t j; \
- for (j = 0; j < number; j++) { \
+ for (size_t j = 0; j < number; j++) { \
sfree(names[j]); \
names[j] = NULL; \
} \
char **names = NULL;
cdtime_t *times = NULL;
size_t number = 0;
- size_t i;
int status;
DEBUG ("utils_cmd_listval: handle_listval (fh = %p, buffer = %s);",
print_to_socket (fh, "%i Value%s found\n",
(int) number, (number == 1) ? "" : "s");
- for (i = 0; i < number; i++)
+ for (size_t i = 0; i < number; i++)
print_to_socket (fh, "%.3f %s\n", CDTIME_T_TO_DOUBLE (times[i]),
names[i]);
uint32_t
crc32_buffer(const unsigned char *s, size_t len)
{
- size_t i;
uint32_t ret;
ret = 0;
- for (i = 0; i < len; i++)
+ for (size_t i = 0; i < len; i++)
ret = crc32_tab[(ret ^ s[i]) & 0xff] ^ (ret >> 8);
return ret;
}
curl_stats_t *curl_stats_from_config (oconfig_item_t *ci)
{
curl_stats_t *s;
- int i;
if (ci == NULL)
return NULL;
if (s == NULL)
return NULL;
- for (i = 0; i < ci->children_num; ++i)
+ for (int i = 0; i < ci->children_num; ++i)
{
oconfig_item_t *c = ci->children + i;
size_t field;
const char *hostname, const char *plugin, const char *plugin_instance)
{
value_list_t vl = VALUE_LIST_INIT;
- size_t field;
if (s == NULL)
return 0;
if (plugin_instance != NULL)
sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
- for (field = 0; field < STATIC_ARRAY_SIZE (field_specs); ++field)
+ for (size_t field = 0; field < STATIC_ARRAY_SIZE (field_specs); ++field)
{
int status;
{
char **array;
size_t array_len;
- int i;
if (ci->values_num < 1)
{
return (-1);
}
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
if (ci->values[i].type != OCONFIG_TYPE_STRING)
{
}
*ret_array = array;
- for (i = 0; i < ci->values_num; i++)
+ for (int i = 0; i < ci->values_num; i++)
{
array[array_len] = strdup (ci->values[i].value.string);
if (array[array_len] == NULL)
udb_query_t const *q, udb_query_preparation_area_t *q_area)
{
value_list_t vl = VALUE_LIST_INIT;
- size_t i;
int status;
assert (r != NULL);
}
vl.values_len = r_area->ds->ds_num;
- for (i = 0; i < r->values_num; i++)
+ for (size_t i = 0; i < r->values_num; i++)
{
char *value_str = r_area->values_buffer[i];
return (-ENOMEM);
}
- for (i = 0; i < r->metadata_num; i++)
+ for (size_t i = 0; i < r->metadata_num; i++)
{
status = meta_data_add_string (vl.meta, r->metadata[i],
r_area->metadata_buffer[i]);
udb_result_preparation_area_t *r_area,
udb_query_t const *q, char **column_values)
{
- size_t i;
-
assert (r && q_area && r_area);
- for (i = 0; i < r->instances_num; i++)
+ for (size_t i = 0; i < r->instances_num; i++)
r_area->instances_buffer[i] = column_values[r_area->instances_pos[i]];
- for (i = 0; i < r->values_num; i++)
+ for (size_t i = 0; i < r->values_num; i++)
r_area->values_buffer[i] = column_values[r_area->values_pos[i]];
- for (i = 0; i < r->metadata_num; i++)
+ for (size_t i = 0; i < r->metadata_num; i++)
r_area->metadata_buffer[i] = column_values[r_area->metadata_pos[i]];
if (q->plugin_instance_from)
udb_result_preparation_area_t *prep_area,
char **column_names, size_t column_num)
{
- size_t i;
-
if ((r == NULL) || (prep_area == NULL))
return (-EINVAL);
/* }}} */
/* Determine the position of the plugin instance column {{{ */
- for (i = 0; i < r->instances_num; i++)
+ for (size_t i = 0; i < r->instances_num; i++)
{
size_t j;
/* Determine the position of the value columns {{{ */
- for (i = 0; i < r->values_num; i++)
+ for (size_t i = 0; i < r->values_num; i++)
{
size_t j;
} /* }}} for (i = 0; i < r->values_num; i++) */
/* Determine the position of the metadata columns {{{ */
- for (i = 0; i < r->metadata_num; i++)
+ for (size_t i = 0; i < r->metadata_num; i++)
{
size_t j;
static void udb_result_free (udb_result_t *r) /* {{{ */
{
- size_t i;
-
if (r == NULL)
return;
sfree (r->type);
sfree (r->instance_prefix);
- for (i = 0; i < r->instances_num; i++)
+ for (size_t i = 0; i < r->instances_num; i++)
sfree (r->instances[i]);
sfree (r->instances);
- for (i = 0; i < r->values_num; i++)
+ for (size_t i = 0; i < r->values_num; i++)
sfree (r->values[i]);
sfree (r->values);
- for (i = 0; i < r->metadata_num; i++)
+ for (size_t i = 0; i < r->metadata_num; i++)
sfree (r->metadata[i]);
sfree (r->metadata);
{
udb_result_t *r;
int status;
- int i;
if (ci->values_num != 0)
{
/* Fill the `udb_result_t' structure.. */
status = 0;
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
udb_query_t *q;
int status;
- int i;
if ((ret_query_list == NULL) || (ret_query_list_len == NULL))
return (-EINVAL);
}
/* Fill the `udb_query_t' structure.. */
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
void udb_query_free (udb_query_t **query_list, size_t query_list_len) /* {{{ */
{
- size_t i;
-
if (query_list == NULL)
return;
- for (i = 0; i < query_list_len; i++)
+ for (size_t i = 0; i < query_list_len; i++)
udb_query_free_one (query_list[i]);
sfree (query_list);
udb_query_t **src_list, size_t src_list_len,
udb_query_t ***dst_list, size_t *dst_list_len)
{
- size_t i;
int num_added;
if ((name == NULL) || (src_list == NULL) || (dst_list == NULL)
}
num_added = 0;
- for (i = 0; i < src_list_len; i++)
+ for (size_t i = 0; i < src_list_len; i++)
{
udb_query_t **tmp_list;
size_t tmp_list_len;
#if defined(COLLECT_DEBUG) && COLLECT_DEBUG /* {{{ */
do
{
- size_t i;
-
- for (i = 0; i < prep_area->column_num; i++)
+ for (size_t i = 0; i < prep_area->column_num; i++)
{
DEBUG ("db query utils: udb_query_handle_result (%s, %s): "
"column[%zu] = %s;",
#if defined(COLLECT_DEBUG) && COLLECT_DEBUG
do
{
- size_t i;
-
- for (i = 0; i < column_num; i++)
+ for (size_t i = 0; i < column_num; i++)
{
DEBUG ("db query utils: udb_query_prepare_result: "
"query = %s; column[%zu] = %s;",
static inline int ignore_list_match (const struct in6_addr *addr)
{
- ip_list_t *ptr;
-
- for (ptr = IgnoreList; ptr != NULL; ptr = ptr->next)
+ for (ip_list_t *ptr = IgnoreList; ptr != NULL; ptr = ptr->next)
if (cmp_in6_addr (addr, &ptr->addr) == 0)
return (1);
return (0);
void ignore_list_add_name (const char *name)
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
struct in6_addr addr;
int status;
if (status != 0)
return;
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
if (ai_ptr->ai_family == AF_INET)
{
static void gr_copy_escape_part (char *dst, const char *src, size_t dst_len,
char escape_char)
{
- size_t i;
-
memset (dst, 0, dst_len);
if (src == NULL)
return;
- for (i = 0; i < dst_len; i++)
+ for (size_t i = 0; i < dst_len; i++)
{
if (src[i] == 0)
{
static void escape_graphite_string (char *buffer, char escape_char)
{
- char *head;
-
assert (strchr(GRAPHITE_FORBIDDEN, escape_char) == NULL);
- for (head = buffer + strcspn(buffer, GRAPHITE_FORBIDDEN);
+ for (char *head = buffer + strcspn(buffer, GRAPHITE_FORBIDDEN);
*head != '\0';
head += strcspn(head, GRAPHITE_FORBIDDEN))
*head = escape_char;
unsigned int flags)
{
int status = 0;
- size_t i;
int buffer_pos = 0;
gauge_t *rates = NULL;
if (flags & GRAPHITE_STORE_RATES)
rates = uc_get_rate (ds, vl);
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
char const *ds_name = NULL;
char key[10*DATA_MAX_NAME_LEN];
static int json_escape_string (char *buffer, size_t buffer_size, /* {{{ */
const char *string)
{
- size_t src_pos;
size_t dst_pos;
if ((buffer == NULL) || (string == NULL))
/* Escape special characters */
BUFFER_ADD ('"');
- for (src_pos = 0; string[src_pos] != 0; src_pos++)
+ for (size_t src_pos = 0; string[src_pos] != 0; src_pos++)
{
if ((string[src_pos] == '"')
|| (string[src_pos] == '\\'))
const data_set_t *ds, const value_list_t *vl, int store_rates)
{
size_t offset = 0;
- size_t i;
gauge_t *rates = NULL;
memset (buffer, 0, buffer_size);
} while (0)
BUFFER_ADD ("[");
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if (i > 0)
BUFFER_ADD (",");
const data_set_t *ds)
{
size_t offset = 0;
- size_t i;
memset (buffer, 0, buffer_size);
} while (0)
BUFFER_ADD ("[");
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if (i > 0)
BUFFER_ADD (",");
const data_set_t *ds)
{
size_t offset = 0;
- size_t i;
memset (buffer, 0, buffer_size);
} while (0)
BUFFER_ADD ("[");
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
if (i > 0)
BUFFER_ADD (",");
{
size_t offset = 0;
int status;
- size_t i;
buffer[0] = 0;
offset += ((size_t) status); \
} while (0)
- for (i = 0; i < keys_num; ++i)
+ for (size_t i = 0; i < keys_num; ++i)
{
int type;
char *key = keys[i];
char **keys = NULL;
size_t keys_num;
int status;
- size_t i;
if ((buffer == NULL) || (buffer_size == 0) || (meta == NULL))
return (EINVAL);
status = meta_data_keys_to_json (buffer, buffer_size, meta, keys, keys_num);
- for (i = 0; i < keys_num; ++i)
+ for (size_t i = 0; i < keys_num; ++i)
sfree (keys[i]);
sfree (keys);
static int kairosdb_escape_string (char *buffer, size_t buffer_size, /* {{{ */
const char *string)
{
- size_t src_pos;
size_t dst_pos;
if ((buffer == NULL) || (string == NULL))
/* Escape special characters */
/* authorize -_. and alpha num but also escapes " */
BUFFER_ADD ('"');
- for (src_pos = 0; string[src_pos] != 0; src_pos++)
+ for (size_t src_pos = 0; string[src_pos] != 0; src_pos++)
{
if (isalnum(string[src_pos]) ||
0x2d == string[src_pos] ||
char temp[512];
size_t offset = 0;
int status;
- size_t i;
memset (buffer, 0, buffer_size);
BUFFER_ADD (",\"%s\": %s", (key), temp); \
} while (0)
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
/* All value lists have a leading comma. The first one will be replaced with
* a square bracket in `format_kairosdb_finalize'. */
if (lc->num > 0) // if the histogram has data then iterate else skip
{
double width_change_ratio = ((double) old_bin_width) / ((double) new_bin_width);
- size_t i;
- for (i = 0; i < HISTOGRAM_NUM_BINS; i++)
+ for (size_t i = 0; i < HISTOGRAM_NUM_BINS; i++)
{
size_t new_bin = (size_t) (((double) i) * width_change_ratio);
if (i == new_bin)
{ 99, 0.3, 99, 103, 20.6},
/* { -1, 0.3, 99, 103, 20.6}, see issue #1139 */
};
- size_t i;
latency_counter_t *l;
CHECK_NOT_NULL (l = latency_counter_create ());
- for (i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
+ for (size_t i = 0; i < STATIC_ARRAY_SIZE (cases); i++) {
printf ("# case %zu: DOUBLE_TO_CDTIME_T(%g) = %"PRIu64"\n",
i, cases[i].val, DOUBLE_TO_CDTIME_T (cases[i].val));
latency_counter_add (l, DOUBLE_TO_CDTIME_T (cases[i].val));
DEF_TEST(percentile)
{
- size_t i;
latency_counter_t *l;
CHECK_NOT_NULL (l = latency_counter_create ());
- for (i = 0; i < 100; i++) {
+ for (size_t i = 0; i < 100; i++) {
latency_counter_add (l, TIME_T_TO_CDTIME_T (((time_t) i) + 1));
}
FILE *procpt;
char uuid[16], *label = NULL;
char device[110];
- int firstPass;
int handleOnFirst;
if(uuidCache) {
return;
}
- for(firstPass = 1; firstPass >= 0; firstPass--) {
+ for(int firstPass = 1; firstPass >= 0; firstPass--) {
fseek(procpt, 0, SEEK_SET);
while(fgets(line, sizeof(line), procpt)) {
if(sscanf(line, " %d %d %d %[^\n ]",
get_spec_by_uuid(const char *s)
{
char uuid[16];
- int i;
if(strlen(s) != 36
|| s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-') {
goto bad_uuid;
}
- for(i=0; i<16; i++) {
+ for(int i=0; i<16; i++) {
if(*s == '-') {
s++;
}
static cu_mount_t *cu_mount_listmntent (void)
{
cu_mount_t *last = *list;
- struct tabmntent *p;
struct mntent *mnt;
struct tabmntent *mntlist;
#endif /* COLLECT_DEBUG */
}
- for(p = mntlist; p; p = p->next) {
+ for(struct tabmntent *p = mntlist; p; p = p->next) {
char *loop = NULL, *device = NULL;
mnt = p->ment;
STRUCT_STATFS *buf;
int num;
- int i;
cu_mount_t *first = NULL;
cu_mount_t *last = NULL;
return (NULL);
}
- for (i = 0; i < num; i++)
+ for (int i = 0; i < num; i++)
{
if ((new = calloc (1, sizeof (*new))) == NULL)
break;
void cu_mount_freelist (cu_mount_t *list)
{
- cu_mount_t *this;
cu_mount_t *next;
- for (this = list; this != NULL; this = next)
+ for (cu_mount_t *this = list; this != NULL; this = next)
{
next = this->next;
*/
static void rra_free (int rra_num, char **rra_def) /* {{{ */
{
- int i;
-
- for (i = 0; i < rra_num; i++)
+ for (int i = 0; i < rra_num; i++)
{
sfree (rra_def[i]);
}
sfree (args->filename);
if (args->argv != NULL)
{
- int i;
- for (i = 0; i < args->argc; i++)
+ for (int i = 0; i < args->argc; i++)
sfree (args->argv[i]);
sfree (args->argv);
}
int cdp_num;
int cdp_len;
- int i, j;
/* The stepsize we use here: If it is user-set, use it. If not, use the
* interval of the value-list. */
rra_num = 0;
cdp_len = 0;
- for (i = 0; i < rts_num; i++)
+ for (int i = 0; i < rts_num; i++)
{
int span = rts[i];
cdp_num = (int) ceil (((double) span)
/ ((double) (cdp_len * ss)));
- for (j = 0; j < rra_types_num; j++)
+ for (int j = 0; j < rra_types_num; j++)
{
char buffer[128];
int status;
static void ds_free (int ds_num, char **ds_def) /* {{{ */
{
- int i;
-
- for (i = 0; i < ds_num; i++)
+ for (int i = 0; i < ds_num; i++)
if (ds_def[i] != NULL)
free (ds_def[i]);
free (ds_def);
user_config_t *conf;
user_data_t ud;
char callback_name[DATA_MAX_NAME_LEN];
- int i;
conf = calloc (1, sizeof (*conf));
if (conf == NULL)
return (EINVAL);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int varnish_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static void
init_value_list (value_list_t *vl, virDomainPtr dom)
{
- int i, n;
+ int n;
const char *name;
char uuid[VIR_UUID_STRING_BUFLEN];
vl->host[0] = '\0';
/* Construct the hostname field according to HostnameFormat. */
- for (i = 0; i < HF_MAX_FIELDS; ++i) {
+ for (int i = 0; i < HF_MAX_FIELDS; ++i) {
if (hostname_format[i] == hf_none)
continue;
vl->host[sizeof (vl->host) - 1] = '\0';
/* Construct the plugin instance field according to PluginInstanceFormat. */
- for (i = 0; i < PLGINST_MAX_FIELDS; ++i) {
+ for (int i = 0; i < PLGINST_MAX_FIELDS; ++i) {
if (plugin_instance_format[i] == plginst_none)
continue;
if (strcasecmp (key, "HostnameFormat") == 0) {
char *value_copy;
char *fields[HF_MAX_FIELDS];
- int i, n;
+ int n;
value_copy = strdup (value);
if (value_copy == NULL) {
return -1;
}
- for (i = 0; i < n; ++i) {
+ for (int i = 0; i < n; ++i) {
if (strcasecmp (fields[i], "hostname") == 0)
hostname_format[i] = hf_hostname;
else if (strcasecmp (fields[i], "name") == 0)
}
sfree (value_copy);
- for (i = n; i < HF_MAX_FIELDS; ++i)
+ for (int i = n; i < HF_MAX_FIELDS; ++i)
hostname_format[i] = hf_none;
return 0;
if (strcasecmp (key, "PluginInstanceFormat") == 0) {
char *value_copy;
char *fields[PLGINST_MAX_FIELDS];
- int i, n;
+ int n;
value_copy = strdup (value);
if (value_copy == NULL) {
return -1;
}
- for (i = 0; i < n; ++i) {
+ for (int i = 0; i < n; ++i) {
if (strcasecmp (fields[i], "none") == 0) {
plugin_instance_format[i] = plginst_none;
break;
}
sfree (value_copy);
- for (i = n; i < PLGINST_MAX_FIELDS; ++i)
+ for (int i = n; i < PLGINST_MAX_FIELDS; ++i)
plugin_instance_format[i] = plginst_none;
return 0;
lv_read (void)
{
time_t t;
- int i;
if (conn == NULL) {
/* `conn_string == NULL' is acceptable. */
}
#if 0
- for (i = 0; i < nr_domains; ++i)
+ for (int i = 0; i < nr_domains; ++i)
fprintf (stderr, "domain %s\n", virDomainGetName (domains[i]));
- for (i = 0; i < nr_block_devices; ++i)
+ for (int i = 0; i < nr_block_devices; ++i)
fprintf (stderr, "block device %d %s:%s\n",
i, virDomainGetName (block_devices[i].dom),
block_devices[i].path);
- for (i = 0; i < nr_interface_devices; ++i)
+ for (int i = 0; i < nr_interface_devices; ++i)
fprintf (stderr, "interface device %d %s:%s\n",
i, virDomainGetName (interface_devices[i].dom),
interface_devices[i].path);
#endif
/* Get CPU usage, memory, VCPU usage for each domain. */
- for (i = 0; i < nr_domains; ++i) {
+ for (int i = 0; i < nr_domains; ++i) {
virDomainInfo info;
virVcpuInfoPtr vinfo = NULL;
virDomainMemoryStatPtr minfo = NULL;
int status;
- int j;
status = virDomainGetInfo (domains[i], &info);
if (status != 0)
continue;
}
- for (j = 0; j < info.nrVirtCpu; ++j)
+ for (int j = 0; j < info.nrVirtCpu; ++j)
vcpu_submit (vinfo[j].cpuTime,
domains[i], vinfo[j].number, "virt_vcpu");
continue;
}
- for (j = 0; j < status; j++) {
+ for (int j = 0; j < status; j++) {
memory_stats_submit ((gauge_t) minfo[j].val * 1024, domains[i], minfo[j].tag);
}
/* Get block device stats for each domain. */
- for (i = 0; i < nr_block_devices; ++i) {
+ for (int i = 0; i < nr_block_devices; ++i) {
struct _virDomainBlockStats stats;
if (virDomainBlockStats (block_devices[i].dom, block_devices[i].path,
} /* for (nr_block_devices) */
/* Get interface stats for each domain. */
- for (i = 0; i < nr_interface_devices; ++i) {
+ for (int i = 0; i < nr_interface_devices; ++i) {
struct _virDomainInterfaceStats stats;
char *display_name = NULL;
}
if (n > 0) {
- int i;
int *domids;
/* Get list of domains. */
free_domains ();
/* Fetch each domain and add it to the list, unless ignore. */
- for (i = 0; i < n; ++i) {
+ for (int i = 0; i < n; ++i) {
virDomainPtr dom = NULL;
const char *name;
char *xml = NULL;
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr xpath_ctx = NULL;
xmlXPathObjectPtr xpath_obj = NULL;
- int j;
dom = virDomainLookupByID (conn, domids[i]);
if (dom == NULL) {
xpath_obj->nodesetval == NULL)
goto cont;
- for (j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
+ for (int j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
xmlNodePtr node;
char *path = NULL;
xmlNodeSetPtr xml_interfaces = xpath_obj->nodesetval;
- for (j = 0; j < xml_interfaces->nodeNr; ++j) {
+ for (int j = 0; j < xml_interfaces->nodeNr; ++j) {
char *path = NULL;
char *address = NULL;
xmlNodePtr xml_interface;
xml_interface = xml_interfaces->nodeTab[j];
if (!xml_interface) continue;
- xmlNodePtr child = NULL;
- for (child = xml_interface->children; child; child = child->next) {
+ for (xmlNodePtr child = xml_interface->children; child; child = child->next) {
if (child->type != XML_ELEMENT_NODE) continue;
if (xmlStrEqual(child->name, (const xmlChar *) "target")) {
static void
free_domains (void)
{
- int i;
-
if (domains) {
- for (i = 0; i < nr_domains; ++i)
+ for (int i = 0; i < nr_domains; ++i)
virDomainFree (domains[i]);
sfree (domains);
}
static void
free_block_devices (void)
{
- int i;
-
if (block_devices) {
- for (i = 0; i < nr_block_devices; ++i)
+ for (int i = 0; i < nr_block_devices; ++i)
sfree (block_devices[i].path);
sfree (block_devices);
}
static void
free_interface_devices (void)
{
- int i;
-
if (interface_devices) {
- for (i = 0; i < nr_interface_devices; ++i) {
+ for (int i = 0; i < nr_interface_devices; ++i) {
sfree (interface_devices[i].path);
sfree (interface_devices[i].address);
sfree (interface_devices[i].number);
static int wg_callback_init (struct wg_callback *cb)
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
cdtime_t now;
int status;
}
assert (ai_list != NULL);
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
cb->sock_fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
ai_ptr->ai_protocol);
struct wg_callback *cb;
user_data_t user_data = { 0 };
char callback_name[DATA_MAX_NAME_LEN];
- int i;
int status = 0;
cb = calloc (1, sizeof (*cb));
pthread_mutex_init (&cb->send_lock, /* attr = */ NULL);
C_COMPLAIN_INIT (&cb->init_complaint);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int wg_config (oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
user_data_t user_data = { 0 };
char callback_name[DATA_MAX_NAME_LEN];
int status = 0;
- int i;
cb = calloc (1, sizeof (*cb));
if (cb == NULL)
if (strcasecmp ("URL", ci->key) == 0)
cf_util_get_string (ci, &cb->location);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int wh_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static void kafka_config_topic(rd_kafka_conf_t *conf, oconfig_item_t *ci) /* {{{ */
{
int status;
- int i;
struct kafka_topic_context *tctx;
char *key = NULL;
char *val;
goto errout;
}
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
/*
* The code here could be simplified but makes room
* for easy adding of new options later on.
static int kafka_config(oconfig_item_t *ci) /* {{{ */
{
- int i;
oconfig_item_t *child;
rd_kafka_conf_t *conf;
rd_kafka_conf_res_t ret;
WARNING("cannot allocate kafka configuration.");
return -1;
}
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
child = &ci->children[i];
if (strcasecmp("Topic", child->key) == 0) {
{
bson *ret;
gauge_t *rates;
- int i;
ret = bson_alloc (); /* matched by bson_dealloc() */
if (ret == NULL)
bson_append_string (ret, "type_instance", vl->type_instance);
bson_append_start_array (ret, "values"); /* {{{ */
- for (i = 0; i < ds->ds_num; i++)
+ for (int i = 0; i < ds->ds_num; i++)
{
char key[16];
bson_append_finish_array (ret); /* }}} values */
bson_append_start_array (ret, "dstypes"); /* {{{ */
- for (i = 0; i < ds->ds_num; i++)
+ for (int i = 0; i < ds->ds_num; i++)
{
char key[16];
bson_append_finish_array (ret); /* }}} dstypes */
bson_append_start_array (ret, "dsnames"); /* {{{ */
- for (i = 0; i < ds->ds_num; i++)
+ for (int i = 0; i < ds->ds_num; i++)
{
char key[16];
{
wm_node_t *node;
int status;
- int i;
node = calloc (1, sizeof (*node));
if (node == NULL)
return (status);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int wm_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
wr_node_t *node;
int timeout;
int status;
- int i;
node = calloc (1, sizeof (*node));
if (node == NULL)
return (status);
}
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int wr_config (oconfig_item_t *ci) /* {{{ */
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
riemann_event_t *event;
char service_buffer[6 * DATA_MAX_NAME_LEN];
char const *severity;
- notification_meta_t *meta;
- size_t i;
switch (n->severity) {
case NOTIF_OKAY:
riemann_event_string_attribute_add(event, "type_instance",
n->type_instance);
- for (i = 0; i < riemann_attrs_num; i += 2)
+ for (size_t i = 0; i < riemann_attrs_num; i += 2)
riemann_event_string_attribute_add(event, riemann_attrs[i],
riemann_attrs[i + 1]);
- for (i = 0; i < riemann_tags_num; i++)
+ for (size_t i = 0; i < riemann_tags_num; i++)
riemann_event_tag_add(event, riemann_tags[i]);
if (n->message[0] != 0)
riemann_event_string_attribute_add(event, "description", n->message);
/* Pull in values from threshold and add extra attributes */
- for (meta = n->meta; meta != NULL; meta = meta->next) {
+ for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next) {
if (strcasecmp("CurrentValue", meta->name) == 0 &&
meta->type == NM_TYPE_DOUBLE) {
riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D,
int *statuses)
{ /* {{{ */
int ret = -1;
- size_t i;
int status;
gauge_t values_copy[ds->ds_num];
}
/* Prepare `sum' and `num'. */
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
if (!isnan (values[i]))
{
num++;
if ((num == 0) /* All data sources are undefined. */
|| (sum == 0.0)) /* Sum is zero, cannot calculate percentage. */
{
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
values_copy[i] = NAN;
}
else /* We can actually calculate the percentage. */
{
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
values_copy[i] = 100.0 * values[i] / sum;
}
} /* if (UT_FLAG_PERCENTAGE) */
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
status = ut_check_one_data_source (ds, vl, th, values_copy, i);
if (status != -1) {
static void free_str_list(struct str_list *strs) /* {{{ */
{
- int i;
- for (i=0; i<strs->nb_strs; i++)
+ for (int i=0; i<strs->nb_strs; i++)
free(strs->strs[i]);
free(strs->strs);
}
static int sensu_connect(struct sensu_host *host) /* {{{ */
{
int e;
- struct addrinfo *ai;
char const *node;
char const *service;
struct linger so_linger;
host->s = -1;
- for (ai = host->res; ai != NULL; ai = ai->ai_next) {
+ for (struct addrinfo *ai = host->res; ai != NULL; ai = ai->ai_next) {
// create the socket
if ((host->s = socket(ai->ai_family,
ai->ai_socktype,
int res;
char *ret_str = NULL;
char *temp_str;
- int i;
if (list->nb_strs == 0) {
ret_str = malloc(sizeof(char));
if (ret_str == NULL) {
free(ret_str);
return NULL;
}
- for (i=1; i<list->nb_strs; i++) {
+ for (int i=1; i<list->nb_strs; i++) {
res = asprintf(&ret_str, "%s, \"%s\"", temp_str, list->strs[i]);
free(temp_str);
if (res == -1) {
static void in_place_replace_sensu_name_reserved(char *orig_name) /* {{{ */
{
- int i;
int len=strlen(orig_name);
- for (i=0; i<len; i++) {
+ for (int i=0; i<len; i++) {
// some plugins like ipmi generate special characters in metric name
switch(orig_name[i]) {
case '(': orig_name[i] = '_'; break;
{
char name_buffer[5 * DATA_MAX_NAME_LEN];
char service_buffer[6 * DATA_MAX_NAME_LEN];
- size_t i;
char *ret_str;
char *temp_str;
char *value_str;
}
// add key value attributes from config if any
- for (i = 0; i < sensu_attrs_num; i += 2) {
+ for (size_t i = 0; i < sensu_attrs_num; i += 2) {
res = asprintf(&temp_str, "%s, \"%s\": \"%s\"", ret_str, sensu_attrs[i], sensu_attrs[i+1]);
free(ret_str);
if (res == -1) {
{
char service_buffer[6 * DATA_MAX_NAME_LEN];
char const *severity;
- notification_meta_t *meta;
char *ret_str;
char *temp_str;
int status;
}
// Pull in values from threshold and add extra attributes
- for (meta = n->meta; meta != NULL; meta = meta->next) {
+ for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next) {
if (strcasecmp("CurrentValue", meta->name) == 0 && meta->type == NM_TYPE_DOUBLE) {
res = asprintf(&temp_str, "%s, \"current_value\": \"%.8f\"", ret_str, meta->nm_value.nm_double);
free(ret_str);
int statuses[vl->values_len];
struct sensu_host *host = ud->data;
gauge_t *rates = NULL;
- size_t i;
char *msg;
pthread_mutex_lock(&host->lock);
return -1;
}
}
- for (i = 0; i < vl->values_len; i++) {
+ for (size_t i = 0; i < vl->values_len; i++) {
msg = sensu_value_to_json(host, ds, vl, (int) i, rates, statuses[i]);
if (msg == NULL) {
sfree(rates);
{
struct sensu_host *host = NULL;
int status = 0;
- int i;
oconfig_item_t *child;
char callback_name[DATA_MAX_NAME_LEN];
user_data_t ud;
return -1;
}
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
child = &ci->children[i];
status = 0;
static int sensu_config(oconfig_item_t *ci) /* {{{ */
{
- int i;
oconfig_item_t *child;
int status;
struct str_list sensu_tags_arr;
sensu_tags_arr.nb_strs = 0;
sensu_tags_arr.strs = NULL;
- for (i = 0; i < ci->children_num; i++) {
+ for (int i = 0; i < ci->children_num; i++) {
child = &ci->children[i];
if (strcasecmp("Node", child->key) == 0) {
static int wt_callback_init(struct wt_callback *cb)
{
struct addrinfo *ai_list;
- struct addrinfo *ai_ptr;
int status;
const char *node = cb->node ? cb->node : WT_DEFAULT_NODE;
}
assert (ai_list != NULL);
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
+ for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
cb->sock_fd = socket(ai_ptr->ai_family, ai_ptr->ai_socktype,
ai_ptr->ai_protocol);
char values[512];
int status;
- size_t i;
if (0 != strcmp(ds->type, vl->type))
{
return -1;
}
- for (i = 0; i < ds->ds_num; i++)
+ for (size_t i = 0; i < ds->ds_num; i++)
{
const char *ds_name = NULL;
struct wt_callback *cb;
user_data_t user_data = { 0 };
char callback_name[DATA_MAX_NAME_LEN];
- int i;
cb = calloc(1, sizeof(*cb));
if (cb == NULL)
pthread_mutex_init (&cb->send_lock, NULL);
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
static int wt_config(oconfig_item_t *ci)
{
- int i;
-
- for (i = 0; i < ci->children_num; i++)
+ for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
return (-1);
}
- int cpu, status;
- for (cpu = 0; cpu < nr_cpus; cpu++) {
+ int status;
+ for (int cpu = 0; cpu < nr_cpus; cpu++) {
gauge_t rate = NAN;
value_t value = {.derive = cpu_info[cpu].idletime};
static void free_zfs_values (kstat_t *ksp)
{
- llentry_t *e;
-
if (ksp == NULL)
return;
- for (e = llist_head (ksp); e != NULL; e = e->next)
+ for (llentry_t *e = llist_head (ksp); e != NULL; e = e->next)
{
sfree (e->key);
sfree (e->value);
{
int sk = -1;
int status;
- struct addrinfo *ai;
struct addrinfo *ai_list;
const char *host;
const char *port;
return (-1);
}
- for (ai = ai_list; ai != NULL; ai = ai->ai_next)
+ for (struct addrinfo *ai = ai_list; ai != NULL; ai = ai->ai_next)
{
sk = socket (ai->ai_family, SOCK_STREAM, 0);
if (sk < 0)
projects / collectd.git / commitdiff