![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 57b9e83)
raw | patch | inline | side by side (parent: 57b9e83)
| author | Ruben Kerkhof <ruben@rubenkerkhof.com> | |
| Sat, 13 May 2017 12:41:48 +0000 (14:41 +0200) | ||
| committer | Ruben Kerkhof <ruben@rubenkerkhof.com> | |
| Sat, 13 May 2017 14:19:02 +0000 (16:19 +0200) |
They don't do any harm but they are not really needed either.
Contributors are not used to following this style, and reviewers have to
keep pointing it out in reviews. This takes up valuable time for both
the contributor and the reviewer and distracts from the more important
issues.
I used the following Coccinelle patch:
@@
expression e;
@@
- return (e);
+ return e;
spatch is having trouble with some files so I have cleaned up the rest
with a few regexes.
Contributors are not used to following this style, and reviewers have to
keep pointing it out in reviews. This takes up valuable time for both
the contributor and the reviewer and distracts from the more important
issues.
I used the following Coccinelle patch:
@@
expression e;
@@
- return (e);
+ return e;
spatch is having trouble with some files so I have cleaned up the rest
with a few regexes.
201 files changed:
diff --git a/configure.ac b/configure.ac
index 3962fc999a47797f1eb21b282d0e7a630a715b54..1142910b16a42b54e9c13c332416035664f118c2 100644 (file)
--- a/configure.ac
+++ b/configure.ac
&& (c[2] == 0xc0) && (c[3] == 0xc7)
&& (c[4] == 0x43) && (c[5] == 0x2b)
&& (c[6] == 0x1f) && (c[7] == 0x5b))
- return (0);
- return (1);
+ return 0;
+ return 1;
]]
)
],
&& (c[2] == 0xc0) && (c[3] == 0xc7)
&& (c[4] == 0x43) && (c[5] == 0x2b)
&& (c[6] == 0x1f) && (c[7] == 0x5b))
- return (0);
- return (1);
+ return 0;
+ return 1;
]]
)
],
&& (c[2] == 0xc0) && (c[3] == 0xc7)
&& (c[4] == 0x43) && (c[5] == 0x2b)
&& (c[6] == 0x1f) && (c[7] == 0x5b))
- return (0);
- return (1);
+ return 0;
+ return 1;
]]
)
],
]],
[[
int retval = TCA_STATS2;
- return (retval);
+ return retval;
]]
)
],
]],
[[
int retval = TCA_STATS;
- return (retval);
+ return retval;
]]
)
],
diff --git a/src/aggregation.c b/src/aggregation.c
index 8d501f63edf5e405e8c2bdf5cee67800938d7cee..ffee1cd4b9489eb904eb87145d2e5fab10466955 100644 (file)
--- a/src/aggregation.c
+++ b/src/aggregation.c
size_t len;
if (str == NULL)
- return (0);
+ return 0;
len = strlen(str);
if (len < 3)
- return (0);
+ return 0;
if ((str[0] == '/') && (str[len - 1] == '/'))
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* }}} _Bool agg_is_regex */
static void agg_destroy(aggregation_t *agg) /* {{{ */
#undef COPY_FIELD
- return (0);
+ return 0;
} /* }}} int agg_instance_create_name */
/* Create a new aggregation instance. */
inst = calloc(1, sizeof(*inst));
if (inst == NULL) {
ERROR("aggregation plugin: calloc() failed.");
- return (NULL);
+ return NULL;
}
pthread_mutex_init(&inst->lock, /* attr = */ NULL);
agg_instance_destroy(inst); \
free(inst); \
ERROR("aggregation plugin: calloc() failed."); \
- return (NULL); \
+ return NULL; \
} \
} \
} while (0)
agg_instance_list_head = inst;
pthread_mutex_unlock(&agg_instance_list_lock);
- return (inst);
+ return inst;
} /* }}} agg_instance_t *agg_instance_create */
/* Update the num, sum, min, max, ... fields of the aggregation instance, if
"data source. This is currently not supported by this plugin. "
"Sorry.",
ds->type);
- return (EINVAL);
+ return EINVAL;
}
rate = uc_get_rate(ds, vl);
FORMAT_VL(ident, sizeof(ident), vl);
ERROR("aggregation plugin: Unable to read the current rate of \"%s\".",
ident);
- return (ENOENT);
+ return ENOENT;
}
if (isnan(rate[0])) {
sfree(rate);
- return (0);
+ return 0;
}
pthread_mutex_lock(&inst->lock);
pthread_mutex_unlock(&inst->lock);
sfree(rate);
- return (0);
+ return 0;
} /* }}} int agg_instance_update */
static int agg_instance_read_func(agg_instance_t *inst, /* {{{ */
* COUNTER or a DERIVE, it will return EAGAIN. Catch this and handle
* gracefully. */
if (status == EAGAIN)
- return (0);
+ return 0;
WARNING("aggregation plugin: rate_to_value failed with status %i.", status);
- return (-1);
+ return -1;
}
vl->values = &v;
vl->values = NULL;
vl->values_len = 0;
- return (0);
+ return 0;
} /* }}} int agg_instance_read_func */
static int agg_instance_read(agg_instance_t *inst, cdtime_t t) /* {{{ */
vl.meta = meta_data_create();
if (vl.meta == NULL) {
ERROR("aggregation plugin: meta_data_create failed.");
- return (-1);
+ return -1;
}
meta_data_add_boolean(vl.meta, "aggregation:created", 1);
meta_data_destroy(vl.meta);
vl.meta = NULL;
- return (0);
+ return 0;
} /* }}} int agg_instance_read */
/* lookup_class_callback_t for utils_vl_lookup */
data_set_t const *ds,
value_list_t const *vl,
void *user_class) {
- return (agg_instance_create(ds, vl, (aggregation_t *)user_class));
+ return agg_instance_create(ds, vl, (aggregation_t *)user_class);
} /* }}} void *agg_class_callback */
/* lookup_obj_callback_t for utils_vl_lookup */
value_list_t const *vl,
__attribute__((unused)) void *user_class,
void *user_obj) {
- return (agg_instance_update((agg_instance_t *)user_obj, ds, vl));
+ return agg_instance_update((agg_instance_t *)user_obj, ds, vl);
} /* }}} int agg_lookup_obj_callback */
/* lookup_free_class_callback_t for utils_vl_lookup */
value);
} /* for (ci->values) */
- return (0);
+ return 0;
} /* }}} int agg_config_handle_group_by */
static int agg_config_aggregation(oconfig_item_t *ci) /* {{{ */
agg = calloc(1, sizeof(*agg));
if (agg == NULL) {
ERROR("aggregation plugin: calloc failed.");
- return (-1);
+ return -1;
}
sstrncpy(agg->ident.host, "/.*/", sizeof(agg->ident.host));
if (!is_valid) /* {{{ */
{
sfree(agg);
- return (-1);
+ return -1;
} /* }}} */
status = lookup_add(lookup, &agg->ident, agg->group_by, agg);
if (status != 0) {
ERROR("aggregation plugin: lookup_add failed with status %i.", status);
sfree(agg);
- return (-1);
+ return -1;
}
DEBUG("aggregation plugin: Successfully added aggregation: "
"Type \"%s\", TypeInstance \"%s\")",
agg->ident.host, agg->ident.plugin, agg->ident.plugin_instance,
agg->ident.type, agg->ident.type_instance);
- return (0);
+ return 0;
} /* }}} int agg_config_aggregation */
static int agg_config(oconfig_item_t *ci) /* {{{ */
if (lookup == NULL) {
pthread_mutex_unlock(&agg_instance_list_lock);
ERROR("aggregation plugin: lookup_create failed.");
- return (-1);
+ return -1;
}
}
pthread_mutex_unlock(&agg_instance_list_lock);
- return (0);
+ return 0;
} /* }}} int agg_config */
static int agg_read(void) /* {{{ */
* Therefore we need to handle this case separately. */
if (agg_instance_list_head == NULL) {
pthread_mutex_unlock(&agg_instance_list_lock);
- return (0);
+ return 0;
}
for (agg_instance_t *this = agg_instance_list_head; this != NULL;
pthread_mutex_unlock(&agg_instance_list_lock);
- return ((success > 0) ? 0 : -1);
+ return (success > 0) ? 0 : -1;
} /* }}} int agg_read */
static int agg_write(data_set_t const *ds, value_list_t const *vl, /* {{{ */
(void)meta_data_get_boolean(vl->meta, "aggregation:created",
&created_by_aggregation);
if (created_by_aggregation)
- return (0);
+ return 0;
if (lookup == NULL)
status = ENOENT;
status = 0;
}
- return (status);
+ return status;
} /* }}} int agg_write */
void module_register(void) {
diff --git a/src/amqp.c b/src/amqp.c
index 4870107cd2758be22e6ac467dbcd653eff24d755..583e4e3c339b2df2d256013285f7622cf03a0f9c 100644 (file)
--- a/src/amqp.c
+++ b/src/amqp.c
char *ret;
if ((in == NULL) || (in->bytes == NULL))
- return (NULL);
+ return NULL;
ret = malloc(in->len + 1);
if (ret == NULL)
- return (NULL);
+ return NULL;
memcpy(ret, in->bytes, in->len);
ret[in->len] = 0;
- return (ret);
+ return ret;
} /* }}} char *camqp_bytes_cstring */
static _Bool camqp_is_error(camqp_config_t *conf) /* {{{ */
r = amqp_get_rpc_reply(conf->connection);
if (r.reply_type == AMQP_RESPONSE_NORMAL)
- return (0);
+ return 0;
- return (1);
+ return 1;
} /* }}} _Bool camqp_is_error */
static char *camqp_strerror(camqp_config_t *conf, /* {{{ */
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
#if HAVE_AMQP_RPC_REPLY_T_LIBRARY_ERRNO
if (r.library_errno)
- return (sstrerror(r.library_errno, buffer, buffer_size));
+ return sstrerror(r.library_errno, buffer, buffer_size);
#else
if (r.library_error)
- return (sstrerror(r.library_error, buffer, buffer_size));
+ return sstrerror(r.library_error, buffer, buffer_size);
#endif
else
sstrncpy(buffer, "End of stream", buffer_size);
ssnprintf(buffer, buffer_size, "Unknown reply type %i", (int)r.reply_type);
}
- return (buffer);
+ return buffer;
} /* }}} char *camqp_strerror */
#if HAVE_AMQP_RPC_REPLY_T_LIBRARY_ERRNO
amqp_exchange_declare_ok_t *ed_ret;
if (conf->exchange_type == NULL)
- return (0);
+ return 0;
ed_ret = amqp_exchange_declare(
conf->connection,
ERROR("amqp plugin: amqp_exchange_declare failed: %s",
camqp_strerror(conf, errbuf, sizeof(errbuf)));
camqp_close_connection(conf);
- return (-1);
+ return -1;
}
INFO("amqp plugin: Successfully created exchange \"%s\" "
"with type \"%s\".",
conf->exchange, conf->exchange_type);
- return (0);
+ return 0;
} /* }}} int camqp_create_exchange */
#else
static int camqp_create_exchange(camqp_config_t *conf) /* {{{ */
struct amqp_table_entry_t_ argument_table_entries[1];
if (conf->exchange_type == NULL)
- return (0);
+ return 0;
/* Valid arguments: "auto_delete", "internal" */
argument_table.num_entries = STATIC_ARRAY_SIZE(argument_table_entries);
ERROR("amqp plugin: amqp_exchange_declare failed: %s",
camqp_strerror(conf, errbuf, sizeof(errbuf)));
camqp_close_connection(conf);
- return (-1);
+ return -1;
}
INFO("amqp plugin: Successfully created exchange \"%s\" "
"with type \"%s\".",
conf->exchange, conf->exchange_type);
- return (0);
+ return 0;
} /* }}} int camqp_create_exchange */
#endif
if (qd_ret == NULL) {
ERROR("amqp plugin: amqp_queue_declare failed.");
camqp_close_connection(conf);
- return (-1);
+ return -1;
}
if (conf->queue == NULL) {
if (conf->queue == NULL) {
ERROR("amqp plugin: camqp_bytes_cstring failed.");
camqp_close_connection(conf);
- return (-1);
+ return -1;
}
INFO("amqp plugin: Created queue \"%s\".", conf->queue);
ERROR("amqp plugin: amqp_queue_bind failed: %s",
camqp_strerror(conf, errbuf, sizeof(errbuf)));
camqp_close_connection(conf);
- return (-1);
+ return -1;
}
DEBUG("amqp plugin: Successfully bound queue \"%s\" to exchange \"%s\".",
ERROR("amqp plugin: amqp_basic_consume failed: %s",
camqp_strerror(conf, errbuf, sizeof(errbuf)));
camqp_close_connection(conf);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int camqp_setup_queue */
static int camqp_connect(camqp_config_t *conf) /* {{{ */
#endif
if (conf->connection != NULL)
- return (0);
+ return 0;
time_t now = time(NULL);
if (now < (last_connect_time + conf->connection_retry_delay)) {
DEBUG("amqp plugin: skipping connection retry, "
"ConnectionRetryDelay: %d",
conf->connection_retry_delay);
- return (1);
+ return 1;
} else {
DEBUG("amqp plugin: retrying connection");
last_connect_time = now;
conf->connection = amqp_new_connection();
if (conf->connection == NULL) {
ERROR("amqp plugin: amqp_new_connection failed.");
- return (ENOMEM);
+ return ENOMEM;
}
#ifdef HAVE_AMQP_TCP_SOCKET
ERROR("amqp plugin: amqp_tcp_socket_new failed.");
amqp_destroy_connection(conf->connection);
conf->connection = NULL;
- return (ENOMEM);
+ return ENOMEM;
}
status = amqp_socket_open(socket, CONF(conf, host), conf->port);
sstrerror(status, errbuf, sizeof(errbuf)));
amqp_destroy_connection(conf->connection);
conf->connection = NULL;
- return (status);
+ return status;
}
#else /* HAVE_AMQP_TCP_SOCKET */
#define CLOSE_SOCKET() close(sockfd)
sstrerror(status, errbuf, sizeof(errbuf)));
amqp_destroy_connection(conf->connection);
conf->connection = NULL;
- return (status);
+ return status;
}
amqp_set_sockfd(conf->connection, sockfd);
#endif
amqp_destroy_connection(conf->connection);
CLOSE_SOCKET();
conf->connection = NULL;
- return (1);
+ return 1;
}
amqp_channel_open(conf->connection, /* channel = */ 1);
amqp_destroy_connection(conf->connection);
CLOSE_SOCKET();
conf->connection = NULL;
- return (1);
+ return 1;
}
INFO("amqp plugin: Successfully opened connection to vhost \"%s\" "
status = camqp_create_exchange(conf);
if (status != 0)
- return (status);
+ return status;
if (!conf->publish)
- return (camqp_setup_queue(conf));
- return (0);
+ return camqp_setup_queue(conf);
+ return 0;
} /* }}} int camqp_connect */
static int camqp_shutdown(void) /* {{{ */
DEBUG("amqp plugin: All subscriber threads exited.");
- return (0);
+ return 0;
} /* }}} int camqp_shutdown */
/*
ERROR("amqp plugin: amqp_simple_wait_frame failed: %s",
sstrerror(status, errbuf, sizeof(errbuf)));
camqp_close_connection(conf);
- return (status);
+ return status;
}
if (frame.frame_type != AMQP_FRAME_BODY) {
NOTICE("amqp plugin: Unexpected frame type: %#" PRIx8, frame.frame_type);
- return (-1);
+ return -1;
}
if ((body_size - received) < frame.payload.body_fragment.len) {
WARNING("amqp plugin: Body is larger than indicated by header.");
- return (-1);
+ return -1;
}
memcpy(body_ptr, frame.payload.body_fragment.bytes,
status = cmd_handle_putval(stderr, body);
if (status != 0)
ERROR("amqp plugin: cmd_handle_putval failed with status %i.", status);
- return (status);
+ return status;
} else if (strcasecmp("application/json", content_type) == 0) {
ERROR("amqp plugin: camqp_read_body: Parsing JSON data has not "
"been implemented yet. FIXME!");
- return (0);
+ return 0;
} else {
ERROR("amqp plugin: camqp_read_body: Unknown content type \"%s\".",
content_type);
- return (EINVAL);
+ return EINVAL;
}
/* not reached */
- return (0);
+ return 0;
} /* }}} int camqp_read_body */
static int camqp_read_header(camqp_config_t *conf) /* {{{ */
ERROR("amqp plugin: amqp_simple_wait_frame failed: %s",
sstrerror(status, errbuf, sizeof(errbuf)));
camqp_close_connection(conf);
- return (status);
+ return status;
}
if (frame.frame_type != AMQP_FRAME_HEADER) {
NOTICE("amqp plugin: Unexpected frame type: %#" PRIx8, frame.frame_type);
- return (-1);
+ return -1;
}
properties = frame.payload.properties.decoded;
content_type = camqp_bytes_cstring(&properties->content_type);
if (content_type == NULL) {
ERROR("amqp plugin: Unable to determine content type.");
- return (-1);
+ return -1;
}
status = camqp_read_body(conf, (size_t)frame.payload.properties.body_size,
content_type);
sfree(content_type);
- return (status);
+ return status;
} /* }}} int camqp_read_header */
static void *camqp_subscribe_thread(void *user_data) /* {{{ */
camqp_config_free(conf);
pthread_exit(NULL);
- return (NULL);
+ return NULL;
} /* }}} void *camqp_subscribe_thread */
static int camqp_subscribe_init(camqp_config_t *conf) /* {{{ */
if (tmp == NULL) {
ERROR("amqp plugin: realloc failed.");
sfree(subscriber_threads);
- return (ENOMEM);
+ return ENOMEM;
}
subscriber_threads = tmp;
tmp = subscriber_threads + subscriber_threads_num;
char errbuf[1024];
ERROR("amqp plugin: pthread_create failed: %s",
sstrerror(status, errbuf, sizeof(errbuf)));
- return (status);
+ return status;
}
subscriber_threads_num++;
- return (0);
+ return 0;
} /* }}} int camqp_subscribe_init */
/*
status = camqp_connect(conf);
if (status != 0)
- return (status);
+ return status;
amqp_basic_properties_t props = {._flags = AMQP_BASIC_CONTENT_TYPE_FLAG |
AMQP_BASIC_DELIVERY_MODE_FLAG |
camqp_close_connection(conf);
}
- return (status);
+ return status;
} /* }}} int camqp_write_locked */
static int camqp_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
int status;
if ((ds == NULL) || (vl == NULL) || (conf == NULL))
- return (EINVAL);
+ return EINVAL;
if (conf->routing_key != NULL) {
sstrncpy(routing_key, conf->routing_key, sizeof(routing_key));
status = cmd_create_putval(buffer, sizeof(buffer), ds, vl);
if (status != 0) {
ERROR("amqp plugin: cmd_create_putval failed with status %i.", status);
- return (status);
+ return status;
}
} else if (conf->format == CAMQP_FORMAT_JSON) {
size_t bfree = sizeof(buffer);
@@ -791,18 +791,18 @@ static int camqp_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
conf->postfix, conf->escape_char, conf->graphite_flags);
if (status != 0) {
ERROR("amqp plugin: format_graphite failed with status %i.", status);
- return (status);
+ return status;
}
} else {
ERROR("amqp plugin: Invalid format (%i).", conf->format);
- return (-1);
+ return -1;
}
pthread_mutex_lock(&conf->lock);
status = camqp_write_locked(conf, buffer, routing_key);
pthread_mutex_unlock(&conf->lock);
- return (status);
+ return status;
} /* }}} int camqp_write */
/*
string = NULL;
status = cf_util_get_string(ci, &string);
if (status != 0)
- return (status);
+ return status;
assert(string != NULL);
if (strcasecmp("Command", string) == 0)
free(string);
- return (0);
+ return 0;
} /* }}} int config_set_string */
static int camqp_config_connection(oconfig_item_t *ci, /* {{{ */
conf = calloc(1, sizeof(*conf));
if (conf == NULL) {
ERROR("amqp plugin: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
/* Initialize "conf" {{{ */
status = cf_util_get_string(ci, &conf->name);
if (status != 0) {
sfree(conf);
- return (status);
+ return status;
}
for (int i = 0; i < ci->children_num; i++) {
if (status != 0) {
camqp_config_free(conf);
- return (status);
+ return status;
}
if (conf->exchange != NULL) {
});
if (status != 0) {
camqp_config_free(conf);
- return (status);
+ return status;
}
} else {
status = camqp_subscribe_init(conf);
if (status != 0) {
camqp_config_free(conf);
- return (status);
+ return status;
}
}
- return (0);
+ return 0;
} /* }}} int camqp_config_connection */
static int camqp_config(oconfig_item_t *ci) /* {{{ */
child->key);
} /* for (ci->children_num) */
- return (0);
+ return 0;
} /* }}} int camqp_config */
void module_register(void) {
diff --git a/src/apache.c b/src/apache.c
index 547d74564684cbeccb20695126e9708ebbe686bf..e2f75c180ae219dfeb81d7abfdfa5fda0b54db25 100644 (file)
--- a/src/apache.c
+++ b/src/apache.c
if (st == NULL) {
ERROR("apache plugin: apache_curl_callback: "
"user_data pointer is NULL.");
- return (0);
+ return 0;
}
if (len == 0)
- return (len);
+ return len;
if ((st->apache_buffer_fill + len) >= st->apache_buffer_size) {
char *temp;
temp = realloc(st->apache_buffer, st->apache_buffer_fill + len + 1);
if (temp == NULL) {
ERROR("apache plugin: realloc failed.");
- return (0);
+ return 0;
}
st->apache_buffer = temp;
st->apache_buffer_size = st->apache_buffer_fill + len + 1;
st->apache_buffer_fill += len;
st->apache_buffer[st->apache_buffer_fill] = 0;
- return (len);
+ return len;
} /* int apache_curl_callback */
static size_t apache_header_callback(void *buf, size_t size, size_t nmemb,
if (st == NULL) {
ERROR("apache plugin: apache_header_callback: "
"user_data pointer is NULL.");
- return (0);
+ return 0;
}
if (len == 0)
- return (len);
+ return len;
/* look for the Server header */
if (strncasecmp(buf, "Server: ", strlen("Server: ")) != 0)
- return (len);
+ return len;
if (strstr(buf, "Apache") != NULL)
st->server_type = APACHE;
NOTICE("apache plugin: Unknown server software: %s", hdr);
}
- return (len);
+ return len;
} /* apache_header_callback */
/* Configuration handling functiions
st = calloc(1, sizeof(*st));
if (st == NULL) {
ERROR("apache plugin: calloc failed.");
- return (-1);
+ return -1;
}
st->timeout = -1;
status = cf_util_get_string(ci, &st->name);
if (status != 0) {
sfree(st);
- return (status);
+ return status;
}
assert(st->name != NULL);
if (status != 0) {
apache_free(st);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int config_add */
static int config(oconfig_item_t *ci) {
child->key);
} /* for (ci->children) */
- return (status);
+ return status;
} /* int config */
/* initialize curl for each host */
if ((st->curl = curl_easy_init()) == NULL) {
ERROR("apache plugin: init_host: `curl_easy_init' failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(st->curl, CURLOPT_NOSIGNAL, 1L);
"truncated.");
curl_easy_cleanup(st->curl);
st->curl = NULL;
- return (-1);
+ return -1;
}
curl_easy_setopt(st->curl, CURLOPT_USERPWD, credentials);
(long)CDTIME_T_TO_MS(plugin_get_interval()));
#endif
- return (0);
+ return 0;
} /* }}} int init_host */
static void submit_value(const char *type, const char *type_instance,
if (st->curl == NULL) {
status = init_host(st);
if (status != 0)
- return (-1);
+ return -1;
}
assert(st->curl != NULL);
st->apache_buffer_fill = 0;
if (curl_easy_perform(st->curl) != CURLE_OK) {
ERROR("apache: curl_easy_perform failed: %s", st->apache_curl_error);
- return (-1);
+ return -1;
}
/* fallback - server_type to apache if not set at this time */
st->apache_buffer_fill = 0;
- return (0);
+ return 0;
} /* }}} int apache_read_host */
static int apache_init(void) /* {{{ */
/* Call this while collectd is still single-threaded to avoid
* initialization issues in libgcrypt. */
curl_global_init(CURL_GLOBAL_SSL);
- return (0);
+ return 0;
} /* }}} int apache_init */
void module_register(void) {
diff --git a/src/apcups.c b/src/apcups.c
index 3b8b03c29d4586d46947cf253826f5c5012a2717..f6ee2dbf4ca5dc4d1b9e2fc69f1a6958b4a6bb8c 100644 (file)
--- a/src/apcups.c
+++ b/src/apcups.c
uint16_t packet_size = 0;
if ((fd == NULL) || (*fd < 0))
- return (EINVAL);
+ return EINVAL;
(void)swrite(*fd, (void *)&packet_size, sizeof(packet_size));
close(*fd);
*fd = -1;
- return (0);
+ return 0;
} /* int net_shutdown */
/* Close the network connection */
static int apcups_shutdown(void) {
if (global_sockfd < 0)
- return (0);
+ return 0;
net_shutdown(&global_sockfd);
- return (0);
+ return 0;
} /* int apcups_shutdown */
/*
INFO("apcups plugin: getaddrinfo failed: %s",
(status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(status));
- return (-1);
+ return -1;
}
/* Create socket */
if (sd < 0) {
DEBUG("apcups plugin: Unable to open a socket");
freeaddrinfo(ai_return);
- return (-1);
+ return -1;
}
status = connect(sd, ai_list->ai_addr, ai_list->ai_addrlen);
INFO("apcups plugin: connect failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(sd);
- return (-1);
+ return -1;
}
DEBUG("apcups plugin: Done opening a socket %i", sd);
- return (sd);
+ return sd;
} /* int net_open */
/*
if (sread(*sockfd, (void *)&packet_size, sizeof(packet_size)) != 0) {
close(*sockfd);
*sockfd = -1;
- return (-1);
+ return -1;
}
packet_size = ntohs(packet_size);
packet_size, buflen);
close(*sockfd);
*sockfd = -1;
- return (-2);
+ return -2;
}
if (packet_size == 0)
- return (0);
+ return 0;
/* now read the actual data */
if (sread(*sockfd, (void *)buf, packet_size) != 0) {
close(*sockfd);
*sockfd = -1;
- return (-1);
+ return -1;
}
- return ((int)packet_size);
+ return (int)packet_size;
} /* static int net_recv (int *sockfd, char *buf, int buflen) */
/*
if (swrite(*sockfd, (void *)&packet_size, sizeof(packet_size)) != 0) {
close(*sockfd);
*sockfd = -1;
- return (-1);
+ return -1;
}
/* send data packet */
if (swrite(*sockfd, (void *)buff, len) != 0) {
close(*sockfd);
*sockfd = -1;
- return (-2);
+ return -2;
}
- return (0);
+ return 0;
}
/* Get and print status from apcupsd NIS server */
if (global_sockfd < 0) {
ERROR("apcups plugin: Connecting to the "
"apcupsd failed.");
- return (-1);
+ return -1;
}
}
}
ERROR("apcups plugin: Writing to the socket failed.");
- return (-1);
+ return -1;
}
break;
char errbuf[1024];
ERROR("apcups plugin: Reading from socket failed: %s",
sstrerror(status, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static int apcups_config(oconfig_item_t *ci) {
}
}
- return (0);
+ return 0;
} /* int apcups_config */
static void apc_submit_generic(const char *type, const char *type_inst,
DEBUG("apcups plugin: apc_query_server (\"%s\", \"%s\") = %d",
conf_node == NULL ? APCUPS_DEFAULT_NODE : conf_node, conf_service,
status);
- return (status);
+ return status;
}
apc_submit(&apcups_detail);
- return (0);
+ return 0;
} /* apcups_read */
void module_register(void) {
diff --git a/src/apple_sensors.c b/src/apple_sensors.c
index 902b5f96ed658aedac0d079432435d3faa4c3d90..f78c3da2025413e576d6d6e51ac0ef077d94e576 100644 (file)
--- a/src/apple_sensors.c
+++ b/src/apple_sensors.c
if (status != kIOReturnSuccess) {
ERROR("IOMasterPort failed: %s", mach_error_string(status));
io_master_port = MACH_PORT_NULL;
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void as_submit(const char *type, const char *type_instance, double val) {
int value_int;
double value_double;
if (!io_master_port || (io_master_port == MACH_PORT_NULL))
- return (-1);
+ return -1;
status = IOServiceGetMatchingServices(
io_master_port, IOServiceNameMatching("IOHWSensor"), &iterator);
if (status != kIOReturnSuccess) {
ERROR("IOServiceGetMatchingServices failed: %s", mach_error_string(status));
- return (-1);
+ return -1;
}
while ((io_obj = IOIteratorNext(iterator))) {
IOObjectRelease(iterator);
- return (0);
+ return 0;
} /* int as_read */
void module_register(void) {
diff --git a/src/aquaero.c b/src/aquaero.c
index 22278e03c2b4bde0523d9c3a7904a39583b8dba5..77835619fb1150e135a1500e8d9ce6c1029d8009 100644 (file)
--- a/src/aquaero.c
+++ b/src/aquaero.c
}
}
- return (0);
+ return 0;
}
static int aquaero_shutdown(void) {
libaquaero5_exit();
- return (0);
+ return 0;
} /* int aquaero_shutdown */
static void aquaero_submit(const char *type, const char *type_instance,
ERROR("aquaero plugin: Failed to poll device \"%s\": %s (%s)",
conf_device ? conf_device : "default", err_msg,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (libaquaero5_getsettings(conf_device, &aq_sett, &err_msg) < 0) {
"for device \"%s\": %s (%s)",
conf_device ? conf_device : "default", err_msg,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* CPU Temperature sensor */
/* Liquid level */
aquaero_submit_array("percent", "waterlevel", aq_data.level, AQ5_NUM_LEVEL);
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/ascent.c b/src/ascent.c
index 5f0d85e763d335774f96c1dac4e364ab3287ff6f..16f9104618207c85313f3e4f128e622fd4875c54 100644 (file)
--- a/src/ascent.c
+++ b/src/ascent.c
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
plugin_dispatch_values(&vl);
- return (0);
+ return 0;
} /* }}} int ascent_submit_gauge */
static size_t ascent_curl_callback(void *buf, size_t size,
size_t len = size * nmemb;
if (len == 0)
- return (len);
+ return len;
if ((ascent_buffer_fill + len) >= ascent_buffer_size) {
char *temp;
temp = realloc(ascent_buffer, ascent_buffer_fill + len + 1);
if (temp == NULL) {
ERROR("ascent plugin: realloc failed.");
- return (0);
+ return 0;
}
ascent_buffer = temp;
ascent_buffer_size = ascent_buffer_fill + len + 1;
ascent_buffer_fill += len;
ascent_buffer[ascent_buffer_fill] = 0;
- return (len);
+ return len;
} /* }}} size_t ascent_curl_callback */
static int ascent_submit_players(player_stats_t *ps) /* {{{ */
value = ((double)ps->latency_sum) / (1000.0 * ((double)ps->latency_num));
ascent_submit_gauge(NULL, "latency", "average", value);
- return (0);
+ return 0;
} /* }}} int ascent_submit_players */
static int ascent_account_player(player_stats_t *ps, /* {{{ */
ps->latency_num++;
}
- return (0);
+ return 0;
} /* }}} int ascent_account_player */
static int ascent_xml_submit_gauge(xmlDoc *doc, xmlNode *node, /* {{{ */
if (str_ptr == NULL) {
ERROR(
"ascent plugin: ascent_xml_submit_gauge: xmlNodeListGetString failed.");
- return (-1);
+ return -1;
}
if (strcasecmp("N/A", str_ptr) == 0)
if (str_ptr == end_ptr) {
xmlFree(str_ptr);
ERROR("ascent plugin: ascent_xml_submit_gauge: strtod failed.");
- return (-1);
+ return -1;
}
}
xmlFree(str_ptr);
- return (ascent_submit_gauge(plugin_instance, type, type_instance, value));
+ return ascent_submit_gauge(plugin_instance, type, type_instance, value);
} /* }}} int ascent_xml_submit_gauge */
static int ascent_xml_read_int(xmlDoc *doc, xmlNode *node, /* {{{ */
str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
if (str_ptr == NULL) {
ERROR("ascent plugin: ascent_xml_read_int: xmlNodeListGetString failed.");
- return (-1);
+ return -1;
}
if (strcasecmp("N/A", str_ptr) == 0)
if (str_ptr == end_ptr) {
xmlFree(str_ptr);
ERROR("ascent plugin: ascent_xml_read_int: strtol failed.");
- return (-1);
+ return -1;
}
}
xmlFree(str_ptr);
*ret_value = value;
- return (0);
+ return 0;
} /* }}} int ascent_xml_read_int */
static int ascent_xml_sessions_plr(xmlDoc *doc, xmlNode *node, /* {{{ */
}
} /* for (child) */
- return (0);
+ return 0;
} /* }}} int ascent_xml_sessions_plr */
static int ascent_xml_sessions(xmlDoc *doc, xmlNode *node) /* {{{ */
ascent_submit_players(&ps);
- return (0);
+ return 0;
} /* }}} int ascent_xml_sessions */
static int ascent_xml_status(xmlDoc *doc, xmlNode *node) /* {{{ */
}
} /* for (child) */
- return (0);
+ return 0;
} /* }}} int ascent_xml_status */
static int ascent_xml(const char *data) /* {{{ */
#endif
if (doc == NULL) {
ERROR("ascent plugin: xmlParseMemory failed.");
- return (-1);
+ return -1;
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
ERROR("ascent plugin: XML document is empty.");
xmlFreeDoc(doc);
- return (-1);
+ return -1;
}
if (xmlStrcmp((const xmlChar *)"serverpage", cur->name) != 0) {
ERROR("ascent plugin: XML root element is not \"serverpage\".");
xmlFreeDoc(doc);
- return (-1);
+ return -1;
}
for (xmlNode *child = cur->xmlChildrenNode; child != NULL;
} /* for (child) */
xmlFreeDoc(doc);
- return (0);
+ return 0;
} /* }}} int ascent_xml */
static int config_set(char **var, const char *value) /* {{{ */
}
if ((*var = strdup(value)) == NULL)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* }}} int config_set */
static int ascent_config(const char *key, const char *value) /* {{{ */
{
if (strcasecmp(key, "URL") == 0)
- return (config_set(&url, value));
+ return config_set(&url, value);
else if (strcasecmp(key, "User") == 0)
- return (config_set(&user, value));
+ return config_set(&user, value);
else if (strcasecmp(key, "Password") == 0)
- return (config_set(&pass, value));
+ return config_set(&pass, value);
else if (strcasecmp(key, "VerifyPeer") == 0)
- return (config_set(&verify_peer, value));
+ return config_set(&verify_peer, value);
else if (strcasecmp(key, "VerifyHost") == 0)
- return (config_set(&verify_host, value));
+ return config_set(&verify_host, value);
else if (strcasecmp(key, "CACert") == 0)
- return (config_set(&cacert, value));
+ return config_set(&cacert, value);
else if (strcasecmp(key, "Timeout") == 0)
- return (config_set(&timeout, value));
+ return config_set(&timeout, value);
else
- return (-1);
+ return -1;
} /* }}} int ascent_config */
static int ascent_init(void) /* {{{ */
if (url == NULL) {
WARNING("ascent plugin: ascent_init: No URL configured, "
"returning an error.");
- return (-1);
+ return -1;
}
if (curl != NULL) {
if ((curl = curl_easy_init()) == NULL) {
ERROR("ascent plugin: ascent_init: curl_easy_init failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
ERROR("ascent plugin: ascent_init: Returning an error because the "
"credentials have been truncated.");
- return (-1);
+ return -1;
}
curl_easy_setopt(curl, CURLOPT_USERPWD, credentials);
(long)CDTIME_T_TO_MS(plugin_get_interval()));
#endif
- return (0);
+ return 0;
} /* }}} int ascent_init */
static int ascent_read(void) /* {{{ */
if (curl == NULL) {
ERROR("ascent plugin: I don't have a CURL object.");
- return (-1);
+ return -1;
}
if (url == NULL) {
ERROR("ascent plugin: No URL has been configured.");
- return (-1);
+ return -1;
}
ascent_buffer_fill = 0;
if (curl_easy_perform(curl) != CURLE_OK) {
ERROR("ascent plugin: curl_easy_perform failed: %s", ascent_curl_error);
- return (-1);
+ return -1;
}
status = ascent_xml(ascent_buffer);
if (status != 0)
- return (-1);
+ return -1;
else
- return (0);
+ return 0;
} /* }}} int ascent_read */
void module_register(void) {
diff --git a/src/battery.c b/src/battery.c
index 78e96b25314dd72052c536c18e2fbb02b3037c79..5a0b089f949fa4d942b94a577e309830d3642d25 100644 (file)
--- a/src/battery.c
+++ b/src/battery.c
kCFStringEncodingASCII);
if (key_obj == NULL) {
DEBUG("CFStringCreateWithCString (%s) failed.\n", key_string);
- return (NAN);
+ return NAN;
}
if ((val_obj = CFDictionaryGetValue(dict, key_obj)) == NULL) {
DEBUG("CFDictionaryGetValue (%s) failed.", key_string);
CFRelease(key_obj);
- return (NAN);
+ return NAN;
}
CFRelease(key_obj);
}
} else {
DEBUG("CFGetTypeID (val_obj) = %i", (int)CFGetTypeID(val_obj));
- return (NAN);
+ return NAN;
}
- return (val_double);
+ return val_double;
} /* }}} double dict_get_double */
#if HAVE_IOKIT_PS_IOPOWERSOURCES_H
if (!isnan(voltage))
battery_submit("0", "voltage", voltage);
- return (0);
+ return 0;
} /* }}} int battery_read */
/* #endif HAVE_IOKIT_IOKITLIB_H || HAVE_IOKIT_PS_IOPOWERSOURCES_H */
status =
sysfs_file_to_buffer(dir, power_supply, basename, buffer, sizeof(buffer));
if (status != 0)
- return (status);
+ return status;
- return (strtogauge(buffer, ret_value));
+ return strtogauge(buffer, ret_value);
} /* }}} sysfs_file_to_gauge */
static int read_sysfs_capacity(char const *dir, /* {{{ */
status =
sysfs_file_to_gauge(dir, power_supply, "energy_now", &capacity_charged);
if (status != 0)
- return (status);
+ return status;
status =
sysfs_file_to_gauge(dir, power_supply, "energy_full", &capacity_full);
if (status != 0)
- return (status);
+ return status;
status = sysfs_file_to_gauge(dir, power_supply, "energy_full_design",
&capacity_design);
if (status != 0)
- return (status);
+ return status;
submit_capacity(plugin_instance, capacity_charged * SYSFS_FACTOR,
capacity_full * SYSFS_FACTOR, capacity_design * SYSFS_FACTOR);
- return (0);
+ return 0;
} /* }}} int read_sysfs_capacity */
static int read_sysfs_callback(char const *dir, /* {{{ */
status =
sysfs_file_to_buffer(dir, power_supply, "type", buffer, sizeof(buffer));
if (status != 0)
- return (0);
+ return 0;
if (strcasecmp("Battery", buffer) != 0)
- return (0);
+ return 0;
(void)sysfs_file_to_buffer(dir, power_supply, "status", buffer,
sizeof(buffer));
if (sysfs_file_to_gauge(dir, power_supply, "voltage_now", &v) == 0)
battery_submit(plugin_instance, "voltage", v * SYSFS_FACTOR);
- return (0);
+ return 0;
} /* }}} int read_sysfs_callback */
static int read_sysfs(void) /* {{{ */
int battery_counter = 0;
if (access(SYSFS_PATH, R_OK) != 0)
- return (ENOENT);
+ return ENOENT;
status = walk_directory(SYSFS_PATH, read_sysfs_callback,
/* user_data = */ &battery_counter,
/* include hidden */ 0);
- return (status);
+ return status;
} /* }}} int read_sysfs */
static int read_acpi_full_capacity(char const *dir, /* {{{ */
ssnprintf(filename, sizeof(filename), "%s/%s/info", dir, power_supply);
fh = fopen(filename, "r");
if (fh == NULL)
- return (errno);
+ return errno;
/* last full capacity: 40090 mWh */
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
}
fclose(fh);
- return (0);
+ return 0;
} /* }}} int read_acpi_full_capacity */
static int read_acpi_callback(char const *dir, /* {{{ */
fh = fopen(filename, "r");
if (fh == NULL) {
if ((errno == EAGAIN) || (errno == EINTR) || (errno == ENOENT))
- return (0);
+ return 0;
else
- return (errno);
+ return errno;
}
/*
int battery_counter = 0;
if (access(PROC_ACPI_PATH, R_OK) != 0)
- return (ENOENT);
+ return ENOENT;
status = walk_directory(PROC_ACPI_PATH, read_acpi_callback,
/* user_data = */ &battery_counter,
/* include hidden */ 0);
- return (status);
+ return status;
} /* }}} int read_acpi */
static int read_pmu(void) /* {{{ */
else if ((errno == EAGAIN) || (errno == EINTR))
continue;
else
- return (errno);
+ return errno;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
}
if (i == 0)
- return (ENOENT);
- return (0);
+ return ENOENT;
+ return 0;
} /* }}} int read_pmu */
static int battery_read(void) /* {{{ */
DEBUG("battery plugin: Trying sysfs ...");
status = read_sysfs();
if (status == 0)
- return (0);
+ return 0;
DEBUG("battery plugin: Trying acpi ...");
status = read_acpi();
if (status == 0)
- return (0);
+ return 0;
DEBUG("battery plugin: Trying pmu ...");
status = read_pmu();
if (status == 0)
- return (0);
+ return 0;
ERROR("battery plugin: All available input methods failed.");
- return (-1);
+ return -1;
} /* }}} int battery_read */
#endif /* KERNEL_LINUX */
child->key);
}
- return (0);
+ return 0;
} /* }}} int battery_config */
void module_register(void) {
diff --git a/src/battery_statefs.c b/src/battery_statefs.c
index 4f6a8c1567a66353274c9fe7f204d88754c78e83..149512b9f48fdf85056dd047da03a85d292ee6b6 100644 (file)
--- a/src/battery_statefs.c
+++ b/src/battery_statefs.c
if (success == 0) {
ERROR("battery plugin: statefs backend: none of the statistics are "
"available");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
diff --git a/src/bind.c b/src/bind.c
index 91e995f99300241630c091ba8f63b8e7cb59bcdc..02bffd3d226d9db6a64a548952d5cffdf46a2ad7 100644 (file)
--- a/src/bind.c
+++ b/src/bind.c
size_t len = size * nmemb;
if (len == 0)
- return (len);
+ return len;
if ((bind_buffer_fill + len) >= bind_buffer_size) {
char *temp;
temp = realloc(bind_buffer, bind_buffer_fill + len + 1);
if (temp == NULL) {
ERROR("bind plugin: realloc failed.");
- return (0);
+ return 0;
}
bind_buffer = temp;
bind_buffer_size = bind_buffer_fill + len + 1;
bind_buffer_fill += len;
bind_buffer[bind_buffer_fill] = 0;
- return (len);
+ return len;
} /* }}} size_t bind_curl_callback */
/*
translation_table_ptr_t *table = (translation_table_ptr_t *)user_data;
if (table == NULL)
- return (-1);
+ return -1;
for (size_t i = 0; i < table->table_length; i++) {
if (strcmp(table->table[i].xml_name, name) != 0)
break;
}
- return (0);
+ return 0;
} /* }}} int bind_xml_table_callback */
/*
list_info_ptr_t *list_info = (list_info_ptr_t *)user_data;
if (list_info == NULL)
- return (-1);
+ return -1;
submit(current_time, list_info->plugin_instance, list_info->type,
/* type instance = */ name, value);
- return (0);
+ return 0;
} /* }}} int bind_xml_list_callback */
static int bind_xml_read_derive(xmlDoc *doc, xmlNode *node, /* {{{ */
str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
if (str_ptr == NULL) {
ERROR("bind plugin: bind_xml_read_derive: xmlNodeListGetString failed.");
- return (-1);
+ return -1;
}
status = parse_value(str_ptr, &value, DS_TYPE_DERIVE);
ERROR("bind plugin: Parsing string \"%s\" to derive value failed.",
str_ptr);
xmlFree(str_ptr);
- return (-1);
+ return -1;
}
xmlFree(str_ptr);
*ret_value = value.derive;
- return (0);
+ return 0;
} /* }}} int bind_xml_read_derive */
static int bind_xml_read_gauge(xmlDoc *doc, xmlNode *node, /* {{{ */
str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
if (str_ptr == NULL) {
ERROR("bind plugin: bind_xml_read_gauge: xmlNodeListGetString failed.");
- return (-1);
+ return -1;
}
errno = 0;
ERROR("bind plugin: bind_xml_read_gauge: strtod failed with overflow.");
else
ERROR("bind plugin: bind_xml_read_gauge: strtod failed.");
- return (-1);
+ return -1;
}
*ret_value = (gauge_t)value;
- return (0);
+ return 0;
} /* }}} int bind_xml_read_gauge */
static int bind_xml_read_timestamp(const char *xpath_expression, /* {{{ */
if (xpathObj == NULL) {
ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
xpath_expression);
- return (-1);
+ return -1;
}
if ((xpathObj->nodesetval == NULL) || (xpathObj->nodesetval->nodeNr < 1)) {
xmlXPathFreeObject(xpathObj);
- return (-1);
+ return -1;
}
if (xpathObj->nodesetval->nodeNr != 1) {
ERROR("bind plugin: bind_xml_read_timestamp: "
"node->xmlChildrenNode == NULL");
xmlXPathFreeObject(xpathObj);
- return (-1);
+ return -1;
}
str_ptr = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
if (str_ptr == NULL) {
ERROR("bind plugin: bind_xml_read_timestamp: xmlNodeListGetString failed.");
xmlXPathFreeObject(xpathObj);
- return (-1);
+ return -1;
}
tmp = strptime(str_ptr, "%Y-%m-%dT%T", &tm);
if (tmp == NULL) {
ERROR("bind plugin: bind_xml_read_timestamp: strptime failed.");
xmlXPathFreeObject(xpathObj);
- return (-1);
+ return -1;
}
#if HAVE_TIMEGM
char errbuf[1024];
ERROR("bind plugin: timegm() failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
*ret_value = t;
#else
char errbuf[1024];
ERROR("bind plugin: mktime() failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* mktime assumes that tm is local time. Luckily, it also sets timezone to
* the offset used for the conversion, and we undo the conversion to convert
#endif
xmlXPathFreeObject(xpathObj);
- return (0);
+ return 0;
} /* }}} int bind_xml_read_timestamp */
/*
@@ -485,7 +485,7 @@ static int bind_parse_generic_name_value(const char *xpath_expression, /* {{{ */
if (xpathObj == NULL) {
ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
xpath_expression);
- return (-1);
+ return -1;
}
num_entries = 0;
@@ -538,7 +538,7 @@ static int bind_parse_generic_name_value(const char *xpath_expression, /* {{{ */
xmlXPathFreeObject(xpathObj);
- return (0);
+ return 0;
} /* }}} int bind_parse_generic_name_value */
/*
@@ -564,7 +564,7 @@ static int bind_parse_generic_value_list(const char *xpath_expression, /* {{{ */
if (xpathObj == NULL) {
ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
xpath_expression);
- return (-1);
+ return -1;
}
num_entries = 0;
@@ -601,7 +601,7 @@ static int bind_parse_generic_value_list(const char *xpath_expression, /* {{{ */
xmlXPathFreeObject(xpathObj);
- return (0);
+ return 0;
} /* }}} int bind_parse_generic_value_list */
/*
if (xpathObj == NULL) {
ERROR("bind plugin: Unable to evaluate XPath expression `%s'.",
xpath_expression);
- return (-1);
+ return -1;
}
num_entries = 0;
xmlXPathFreeObject(xpathObj);
- return (0);
+ return 0;
} /* }}} int bind_parse_generic_name_attr_value_list */
static int bind_xml_stats_handle_zone(int version, xmlDoc *doc, /* {{{ */
path_obj = xmlXPathEvalExpression(BAD_CAST "name", path_ctx);
if (path_obj == NULL) {
ERROR("bind plugin: xmlXPathEvalExpression failed.");
- return (-1);
+ return -1;
}
for (int i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr);
if (zone_name == NULL) {
ERROR("bind plugin: Could not determine zone name.");
- return (-1);
+ return -1;
}
for (j = 0; j < view->zones_num; j++) {
zone_name = NULL;
if (j >= view->zones_num)
- return (0);
+ return 0;
zone_name = view->zones[j];
}
} /* }}} */
- return (0);
+ return 0;
} /* }}} int bind_xml_stats_handle_zone */
static int bind_xml_stats_search_zones(int version, xmlDoc *doc, /* {{{ */
zone_path_context = xmlXPathNewContext(doc);
if (zone_path_context == NULL) {
ERROR("bind plugin: xmlXPathNewContext failed.");
- return (-1);
+ return -1;
}
zone_nodes = xmlXPathEvalExpression(BAD_CAST "zones/zone", path_ctx);
if (zone_nodes == NULL) {
ERROR("bind plugin: Cannot find any <view> tags.");
xmlXPathFreeContext(zone_path_context);
- return (-1);
+ return -1;
}
for (int i = 0; i < zone_nodes->nodesetval->nodeNr; i++) {
xmlXPathFreeObject(zone_nodes);
xmlXPathFreeContext(zone_path_context);
- return (0);
+ return 0;
} /* }}} int bind_xml_stats_search_zones */
static int bind_xml_stats_handle_view(int version, xmlDoc *doc, /* {{{ */
if (view_name == NULL) {
ERROR("bind plugin: Could not determine view name.");
- return (-1);
+ return -1;
}
for (j = 0; j < views_num; j++) {
path_obj = xmlXPathEvalExpression(BAD_CAST "name", path_ctx);
if (path_obj == NULL) {
ERROR("bind plugin: xmlXPathEvalExpression failed.");
- return (-1);
+ return -1;
}
for (int i = 0; path_obj->nodesetval && (i < path_obj->nodesetval->nodeNr);
if (view_name == NULL) {
ERROR("bind plugin: Could not determine view name.");
xmlXPathFreeObject(path_obj);
- return (-1);
+ return -1;
}
for (j = 0; j < views_num; j++) {
}
if (j >= views_num)
- return (0);
+ return 0;
view = views + j;
bind_xml_stats_search_zones(version, doc, path_ctx, node, view,
current_time);
- return (0);
+ return 0;
} /* }}} int bind_xml_stats_handle_view */
static int bind_xml_stats_search_views(int version, xmlDoc *doc, /* {{{ */
view_path_context = xmlXPathNewContext(doc);
if (view_path_context == NULL) {
ERROR("bind plugin: xmlXPathNewContext failed.");
- return (-1);
+ return -1;
}
view_nodes = xmlXPathEvalExpression(BAD_CAST "views/view", xpathCtx);
if (view_nodes == NULL) {
ERROR("bind plugin: Cannot find any <view> tags.");
xmlXPathFreeContext(view_path_context);
- return (-1);
+ return -1;
}
for (int i = 0; i < view_nodes->nodesetval->nodeNr; i++) {
xmlXPathFreeObject(view_nodes);
xmlXPathFreeContext(view_path_context);
- return (0);
+ return 0;
} /* }}} int bind_xml_stats_search_views */
static void bind_xml_stats_v3(xmlDoc *doc, /* {{{ */
¤t_time);
if (status != 0) {
ERROR("bind plugin: Reading `server/current-time' failed.");
- return (-1);
+ return -1;
}
DEBUG("bind plugin: Current server time is %i.", (int)current_time);
doc = xmlParseMemory(data, strlen(data));
if (doc == NULL) {
ERROR("bind plugin: xmlParseMemory failed.");
- return (-1);
+ return -1;
}
xpathCtx = xmlXPathNewContext(doc);
if (xpathCtx == NULL) {
ERROR("bind plugin: xmlXPathNewContext failed.");
xmlFreeDoc(doc);
- return (-1);
+ return -1;
}
//
xmlXPathFreeContext(xpathCtx);
xmlFreeDoc(doc);
- return (ret);
+ return ret;
}
//
ERROR("bind plugin: Cannot find the <statistics> tag.");
xmlXPathFreeContext(xpathCtx);
xmlFreeDoc(doc);
- return (-1);
+ return -1;
} else if (xpathObj->nodesetval == NULL) {
ERROR("bind plugin: xmlXPathEvalExpression failed.");
xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);
xmlFreeDoc(doc);
- return (-1);
+ return -1;
}
for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++) {
xmlXPathFreeContext(xpathCtx);
xmlFreeDoc(doc);
- return (ret);
+ return ret;
} /* }}} int bind_xml */
static int bind_config_set_bool(const char *name, int *var, /* {{{ */
WARNING("bind plugin: The `%s' option needs "
"exactly one boolean argument.",
name);
- return (-1);
+ return -1;
}
if (ci->values[0].value.boolean)
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("bind plugin: The `Zone' option needs "
"exactly one string argument.");
- return (-1);
+ return -1;
}
tmp = realloc(view->zones, sizeof(char *) * (view->zones_num + 1));
if (tmp == NULL) {
ERROR("bind plugin: realloc failed.");
- return (-1);
+ return -1;
}
view->zones = tmp;
view->zones[view->zones_num] = strdup(ci->values[0].value.string);
if (view->zones[view->zones_num] == NULL) {
ERROR("bind plugin: strdup failed.");
- return (-1);
+ return -1;
}
view->zones_num++;
- return (0);
+ return 0;
} /* }}} int bind_config_add_view_zone */
static int bind_config_add_view(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("bind plugin: `View' blocks need exactly one string argument.");
- return (-1);
+ return -1;
}
tmp = realloc(views, sizeof(*views) * (views_num + 1));
if (tmp == NULL) {
ERROR("bind plugin: realloc failed.");
- return (-1);
+ return -1;
}
views = tmp;
tmp = views + views_num;
if (tmp->name == NULL) {
ERROR("bind plugin: strdup failed.");
sfree(views);
- return (-1);
+ return -1;
}
for (int i = 0; i < ci->children_num; i++) {
} /* for (i = 0; i < ci->children_num; i++) */
views_num++;
- return (0);
+ return 0;
} /* }}} int bind_config_add_view */
static int bind_config(oconfig_item_t *ci) /* {{{ */
(child->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("bind plugin: The `Url' option needs "
"exactly one string argument.");
- return (-1);
+ return -1;
}
sfree(url);
}
}
- return (0);
+ return 0;
} /* }}} int bind_config */
static int bind_init(void) /* {{{ */
{
if (curl != NULL)
- return (0);
+ return 0;
curl = curl_easy_init();
if (curl == NULL) {
ERROR("bind plugin: bind_init: curl_easy_init failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
plugin_get_interval()));
#endif
- return (0);
+ return 0;
} /* }}} int bind_init */
static int bind_read(void) /* {{{ */
if (curl == NULL) {
ERROR("bind plugin: I don't have a CURL object.");
- return (-1);
+ return -1;
}
bind_buffer_fill = 0;
if (curl_easy_perform(curl) != CURLE_OK) {
ERROR("bind plugin: curl_easy_perform failed: %s", bind_curl_error);
- return (-1);
+ return -1;
}
status = bind_xml(bind_buffer);
if (status != 0)
- return (-1);
+ return -1;
else
- return (0);
+ return 0;
} /* }}} int bind_read */
static int bind_shutdown(void) /* {{{ */
curl = NULL;
}
- return (0);
+ return 0;
} /* }}} int bind_shutdown */
void module_register(void) {
diff --git a/src/ceph.c b/src/ceph.c
index 2331e33df6881406e82ad4f2a7e5073614c9a84d..c2284cb3baa70d26ad8f7d4a9e09a031158a1929 100644 (file)
--- a/src/ceph.c
+++ b/src/ceph.c
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("ceph plugin: `Daemon' blocks need exactly one string "
"argument.");
- return (-1);
+ return -1;
}
ret = cc_handle_str(ci, cd.name, DATA_MAX_NAME_LEN);
diff --git a/src/cgroups.c b/src/cgroups.c
index 3f7d4f414592e6823a27f88d368c4164e57bdce3..9cb7cf951317951a9df89ef0ecf0d814a920e1ca 100644 (file)
--- a/src/cgroups.c
+++ b/src/cgroups.c
FILE *fh;
if (ignorelist_match(il_cgroup, cgroup_name))
- return (0);
+ return 0;
ssnprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, cgroup_name);
status = lstat(abs_path, &statbuf);
if (status != 0) {
ERROR("cgroups plugin: stat (\"%s\") failed.", abs_path);
- return (-1);
+ return -1;
}
/* We are only interested in directories, so skip everything else. */
if (!S_ISDIR(statbuf.st_mode))
- return (0);
+ return 0;
ssnprintf(abs_path, sizeof(abs_path), "%s/%s/cpuacct.stat", dirname,
cgroup_name);
char errbuf[1024];
ERROR("cgroups plugin: fopen (\"%s\") failed: %s", abs_path,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buf, sizeof(buf), fh) != NULL) {
}
fclose(fh);
- return (0);
+ return 0;
} /* int read_cpuacct_procs */
/*
status = lstat(abs_path, &statbuf);
if (status != 0) {
ERROR("cgroups plugin: stat (%s) failed.", abs_path);
- return (-1);
+ return -1;
}
if (S_ISDIR(statbuf.st_mode)) {
status = walk_directory(abs_path, read_cpuacct_procs,
/* user_data = */ NULL,
/* include_hidden = */ 0);
- return (status);
+ return status;
}
- return (0);
+ return 0;
}
static int cgroups_init(void) {
if (il_cgroup == NULL)
il_cgroup = ignorelist_create(1);
- return (0);
+ return 0;
}
static int cgroups_config(const char *key, const char *value) {
if (strcasecmp(key, "CGroup") == 0) {
if (ignorelist_add(il_cgroup, value))
- return (1);
- return (0);
+ return 1;
+ return 0;
} else if (strcasecmp(key, "IgnoreSelected") == 0) {
if (IS_TRUE(value))
ignorelist_set_invert(il_cgroup, 0);
else
ignorelist_set_invert(il_cgroup, 1);
- return (0);
+ return 0;
}
- return (-1);
+ return -1;
}
static int cgroups_read(void) {
if (cu_mount_getlist(&mnt_list) == NULL) {
ERROR("cgroups plugin: cu_mount_getlist failed.");
- return (-1);
+ return -1;
}
for (cu_mount_t *mnt_ptr = mnt_list; mnt_ptr != NULL;
if (!cgroup_found) {
WARNING("cgroups plugin: Unable to find cgroup "
"mount-point with the \"cpuacct\" option.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int cgroup_read */
void module_register(void) {
diff --git a/src/collectd-nagios.c b/src/collectd-nagios.c
index 993541d8af9b32545a60c7bfab7ce11829cc4505..4c54dad444e49837038477bbee3cad2254731d4c 100644 (file)
--- a/src/collectd-nagios.c
+++ b/src/collectd-nagios.c
ret = (char *)malloc(strsize);
if (ret != NULL)
memcpy(ret, str, strsize);
- return (ret);
+ return ret;
} /* }}} char *cn_strdup */
static int filter_ds(size_t *values_num, double **values,
char **new_names;
if (match_ds_g == NULL)
- return (RET_OKAY);
+ return RET_OKAY;
new_values = (gauge_t *)calloc(match_ds_num_g, sizeof(*new_values));
if (new_values == NULL) {
fprintf(stderr, "calloc failed: %s\n", strerror(errno));
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
new_names = (char **)calloc(match_ds_num_g, sizeof(*new_names));
if (new_names == NULL) {
fprintf(stderr, "calloc failed: %s\n", strerror(errno));
free(new_values);
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
for (size_t i = 0; i < match_ds_num_g; i++) {
for (j = 0; j < i; j++)
free(new_names[j]);
free(new_names);
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
for (j = 0; j < *values_num; j++)
for (j = 0; j <= i; j++)
free(new_names[j]);
free(new_names);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
new_values[i] = (*values)[j];
*values = new_values;
*values_names = new_names;
*values_num = match_ds_num_g;
- return (RET_OKAY);
+ return RET_OKAY;
} /* int filter_ds */
static void parse_range(char *string, range_t *range) {
if (!isnan(range->max) && (range->max < value))
ret = 1;
- return (((ret - range->invert) == 0) ? 0 : 1);
+ return ((ret - range->invert) == 0) ? 0 : 1;
} /* int match_range */
__attribute__((noreturn)) static void usage(const char *name) {
printf("UNKNOWN: %s\n", lcc_strerror(connection));
if (ret_ident != NULL)
free(ret_ident);
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
status = lcc_sort_identifiers(connection, ret_ident, ret_ident_num);
printf("UNKNOWN: %s\n", lcc_strerror(connection));
if (ret_ident != NULL)
free(ret_ident);
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
for (size_t i = 0; i < ret_ident_num; ++i) {
free(ret_ident);
free(hostname);
- return (RET_OKAY);
+ return RET_OKAY;
} /* int do_listval */
static int do_check_con_none(size_t values_num, double *values,
if ((num_critical == 0) && (num_warning == 0) && (num_okay == 0)) {
printf("WARNING: No defined values found\n");
- return (RET_WARNING);
+ return RET_WARNING;
} else if ((num_critical == 0) && (num_warning == 0)) {
status_str = "OKAY";
status_code = RET_OKAY;
}
printf("\n");
- return (status_code);
+ return status_code;
} /* int do_check_con_none */
static int do_check_con_average(size_t values_num, double *values,
continue;
printf("CRITICAL: Data source \"%s\" is NaN\n", values_names[i]);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
total += values[i];
if (total_num == 0) {
printf("WARNING: No defined values found\n");
- return (RET_WARNING);
+ return RET_WARNING;
}
average = total / total_num;
printf(" %s=%f;;;;", values_names[i], values[i]);
printf("\n");
- return (status_code);
+ return status_code;
} /* int do_check_con_average */
static int do_check_con_sum(size_t values_num, double *values,
continue;
printf("CRITICAL: Data source \"%s\" is NaN\n", values_names[i]);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
total += values[i];
if (total_num == 0) {
printf("WARNING: No defined values found\n");
- return (RET_WARNING);
+ return RET_WARNING;
}
if (match_range(&range_critical_g, total) != 0) {
printf(" %s=%f;;;;", values_names[i], values[i]);
printf("\n");
- return (status_code);
+ return status_code;
} /* int do_check_con_sum */
static int do_check_con_percentage(size_t values_num, double *values,
if ((values_num < 1) || (isnan(values[0]))) {
printf("WARNING: The first value is not defined\n");
- return (RET_WARNING);
+ return RET_WARNING;
}
for (size_t i = 0; i < values_num; i++) {
continue;
printf("CRITICAL: Data source \"%s\" is NaN\n", values_names[i]);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
sum += values[i];
if (sum == 0.0) {
printf("WARNING: Values sum up to zero\n");
- return (RET_WARNING);
+ return RET_WARNING;
}
percentage = 100.0 * values[0] / sum;
printf("%s: %lf percent |", status_str, percentage);
for (size_t i = 0; i < values_num; i++)
printf(" %s=%lf;;;;", values_names[i], values[i]);
- return (status_code);
+ return status_code;
} /* int do_check_con_percentage */
static int do_check(lcc_connection_t *connection) {
printf("ERROR: Creating an identifier failed: %s.\n",
lcc_strerror(connection));
LCC_DESTROY(connection);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
status = lcc_getval(connection, &ident, &values_num, &values, &values_names);
printf("ERROR: Retrieving values from the daemon failed: %s.\n",
lcc_strerror(connection));
LCC_DESTROY(connection);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
LCC_DESTROY(connection);
status = filter_ds(&values_num, &values, &values_names);
if (status != RET_OKAY)
- return (status);
+ return status;
status = RET_UNKNOWN;
if (consolitation_g == CON_NONE)
free(values_names[i]);
free(values_names);
- return (status);
+ return status;
} /* int do_check */
int main(int argc, char **argv) {
tmp = realloc(match_ds_g, (match_ds_num_g + 1) * sizeof(char *));
if (tmp == NULL) {
fprintf(stderr, "realloc failed: %s\n", strerror(errno));
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
match_ds_g = tmp;
match_ds_g[match_ds_num_g] = cn_strdup(optarg);
if (match_ds_g[match_ds_num_g] == NULL) {
fprintf(stderr, "cn_strdup failed: %s\n", strerror(errno));
- return (RET_UNKNOWN);
+ return RET_UNKNOWN;
}
match_ds_num_g++;
break;
status = lcc_connect(address, &connection);
if (status != 0) {
printf("ERROR: Connecting to daemon at %s failed.\n", socket_file_g);
- return (RET_CRITICAL);
+ return RET_CRITICAL;
}
if (0 == strcasecmp(value_string_g, "LIST"))
- return (do_listval(connection));
+ return do_listval(connection);
- return (do_check(connection));
+ return do_check(connection);
} /* int main */
diff --git a/src/collectd-tg.c b/src/collectd-tg.c
index 3bde325913c644bd4b48abef02ea89344aef8dad..d8b2ea19d29bbe2b7e945e4c6f83c036e1b6c34e 100644 (file)
--- a/src/collectd-tg.c
+++ b/src/collectd-tg.c
if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
perror("clock_gettime");
- return ((double)ts.tv_sec) + (((double)ts.tv_nsec) / 1e9);
+ return (double)ts.tv_sec + (double)ts.tv_nsec / 1e9;
} /* }}} double dtime */
#else
/* Work around for Mac OS X which doesn't have clock_gettime(2). *sigh* */
if (gettimeofday(&tv, /* timezone = */ NULL) != 0)
perror("gettimeofday");
- return ((double)tv.tv_sec) + (((double)tv.tv_usec) / 1e6);
+ return (double)tv.tv_sec + ((double)tv.tv_usec) / 1e6;
} /* }}} double dtime */
#endif
const lcc_value_list_t *vl1 = v1;
if (vl0->time < vl1->time)
- return (-1);
+ return -1;
else if (vl0->time > vl1->time)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* }}} int compare_time */
static int get_boundet_random(int min, int max) /* {{{ */
int range;
if (min >= max)
- return (-1);
+ return -1;
if (min == (max - 1))
- return (min);
+ return min;
range = max - min;
- return (min + ((int)(((double)range) * ((double)random()) /
- (((double)RAND_MAX) + 1.0))));
+ return min + ((int)(((double)range) * ((double)random()) / (((double)RAND_MAX) + 1.0)));
} /* }}} int get_boundet_random */
static lcc_value_list_t *create_value_list(void) /* {{{ */
vl = calloc(1, sizeof(*vl));
if (vl == NULL) {
fprintf(stderr, "calloc failed.\n");
- return (NULL);
+ return NULL;
}
vl->values = calloc(/* nmemb = */ 1, sizeof(*vl->values));
if (vl->values == NULL) {
fprintf(stderr, "calloc failed.\n");
free(vl);
- return (NULL);
+ return NULL;
}
vl->values_types = calloc(/* nmemb = */ 1, sizeof(*vl->values_types));
fprintf(stderr, "calloc failed.\n");
free(vl->values);
free(vl);
- return (NULL);
+ return NULL;
}
vl->values_len = 1;
snprintf(vl->identifier.type_instance, sizeof(vl->identifier.type_instance),
"ti%li", random());
- return (vl);
+ return vl;
} /* }}} int create_value_list */
static void destroy_value_list(lcc_value_list_t *vl) /* {{{ */
vl->time += vl->interval;
- return (0);
+ return 0;
} /* }}} int send_value */
static int get_integer_opt(const char *str, int *ret_value) /* {{{ */
}
*ret_value = tmp;
- return (0);
+ return 0;
} /* }}} int get_integer_opt */
static int get_double_opt(const char *str, double *ret_value) /* {{{ */
}
*ret_value = tmp;
- return (0);
+ return 0;
} /* }}} int get_double_opt */
static int read_options(int argc, char **argv) /* {{{ */
} /* switch (opt) */
} /* while (getopt) */
- return (0);
+ return 0;
} /* }}} int read_options */
int main(int argc, char **argv) /* {{{ */
diff --git a/src/collectdctl.c b/src/collectdctl.c
index 248baadfb00c196463c63adf21aeb857df74f4b2..4b0db2a7e883c721f0ad49eb14dceddedb84e7c6 100644 (file)
--- a/src/collectdctl.c
+++ b/src/collectdctl.c
tmp = realloc(*array, (*array_len + 1) * elem_size);
if (tmp == NULL) {
fprintf(stderr, "ERROR: Failed to allocate memory.\n");
- return (-1);
+ return -1;
}
*array = tmp;
++(*array_len);
- return (0);
+ return 0;
} /* array_grow */
static int parse_identifier(lcc_connection_t *c, const char *value,
if (gethostname(hostname, sizeof(hostname)) != 0) {
fprintf(stderr, "ERROR: Failed to get local hostname: %s",
strerror(errno));
- return (-1);
+ return -1;
}
hostname[sizeof(hostname) - 1] = '\0';
if (status != 0) {
fprintf(stderr, "ERROR: Failed to parse identifier ``%s'': %s.\n",
ident_str, lcc_strerror(c));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* parse_identifier */
static int getval(lcc_connection_t *c, int argc, char **argv) {
if (argc != 2) {
fprintf(stderr, "ERROR: getval: Missing identifier.\n");
- return (-1);
+ return -1;
}
status = parse_identifier(c, argv[1], &ident);
if (status != 0)
- return (status);
+ return status;
#define BAIL_OUT(s) \
do { \
free(ret_values_names); \
} \
ret_values_num = 0; \
- return (s); \
+ return s; \
} while (0)
status =
if (plugins != NULL) \
free(plugins); \
plugins_num = 0; \
- return (s); \
+ return s; \
} while (0)
for (int i = 1; i < argc; ++i) {
if (argc != 1) {
fprintf(stderr, "ERROR: listval: Does not accept any arguments.\n");
- return (-1);
+ return -1;
}
#define BAIL_OUT(s) \
if (ret_ident != NULL) \
free(ret_ident); \
ret_ident_num = 0; \
- return (s); \
+ return s; \
} while (0)
status = lcc_listval(c, &ret_ident, &ret_ident_num);
if (argc < 3) {
fprintf(stderr, "ERROR: putval: Missing identifier "
"and/or value list.\n");
- return (-1);
+ return -1;
}
vl.values = values;
status = parse_identifier(c, argv[1], &vl.identifier);
if (status != 0)
- return (status);
+ return status;
for (int i = 2; i < argc; ++i) {
char *tmp;
if (endptr == value) {
fprintf(stderr, "ERROR: Failed to parse interval as number: %s.\n",
value);
- return (-1);
+ return -1;
} else if ((endptr != NULL) && (*endptr != '\0')) {
fprintf(stderr, "WARNING: Ignoring trailing garbage after "
"interval: %s.\n",
}
} else {
fprintf(stderr, "ERROR: putval: Unknown option `%s'.\n", key);
- return (-1);
+ return -1;
}
} else { /* value list */
char *value;
if (tmp == NULL) {
fprintf(stderr, "ERROR: putval: Invalid value list: %s.\n", argv[i]);
- return (-1);
+ return -1;
}
*tmp = '\0';
if (endptr == argv[i]) {
fprintf(stderr, "ERROR: Failed to parse time as number: %s.\n",
argv[i]);
- return (-1);
+ return -1;
} else if ((endptr != NULL) && (*endptr != '\0')) {
fprintf(stderr, "ERROR: Garbage after time: %s.\n", endptr);
- return (-1);
+ return -1;
}
}
if (endptr == value) {
fprintf(stderr, "ERROR: Failed to parse value as number: %s.\n",
argv[i]);
- return (-1);
+ return -1;
} else if ((endptr != NULL) && (*endptr != '\0')) {
fprintf(stderr, "ERROR: Garbage after value: %s.\n", endptr);
- return (-1);
+ return -1;
}
value = tmp;
status = lcc_putval(c, &vl);
if (status != 0) {
fprintf(stderr, "ERROR: %s\n", lcc_strerror(c));
- return (-1);
+ return -1;
}
}
}
if (values_len == 0) {
fprintf(stderr, "ERROR: putval: Missing value list(s).\n");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* putval */
int main(int argc, char **argv) {
if (status != 0) {
fprintf(stderr, "ERROR: Failed to connect to daemon at %s: %s.\n", address,
strerror(errno));
- return (1);
+ return 1;
}
if (strcasecmp(argv[optind], "getval") == 0)
status = putval(c, argc - optind, argv + optind);
else {
fprintf(stderr, "%s: invalid command: %s\n", argv[0], argv[optind]);
- return (1);
+ return 1;
}
LCC_DESTROY(c);
if (status != 0)
- return (status);
- return (0);
+ return status;
+ return 0;
} /* main */
diff --git a/src/conntrack.c b/src/conntrack.c
index 8a9200dd734eb7da8c2483eabcd0c7e76f36be59..3cd2deeed3553412a6bfdf6ce672409b8d4aafce 100644 (file)
--- a/src/conntrack.c
+++ b/src/conntrack.c
char const *path = old_files ? CONNTRACK_FILE_OLD : CONNTRACK_FILE;
if (parse_value_file(path, &conntrack, DS_TYPE_GAUGE) != 0) {
ERROR("conntrack plugin: Reading \"%s\" failed.", path);
- return (-1);
+ return -1;
}
path = old_files ? CONNTRACK_MAX_FILE_OLD : CONNTRACK_MAX_FILE;
if (parse_value_file(path, &conntrack_max, DS_TYPE_GAUGE) != 0) {
ERROR("conntrack plugin: Reading \"%s\" failed.", path);
- return (-1);
+ return -1;
}
conntrack_pct.gauge = (conntrack.gauge / conntrack_max.gauge) * 100;
conntrack_submit("conntrack", "max", conntrack_max);
conntrack_submit("percent", "used", conntrack_pct);
- return (0);
+ return 0;
} /* static int conntrack_read */
void module_register(void) {
diff --git a/src/contextswitch.c b/src/contextswitch.c
index 1d73f0417d0d125401def305d9bf76e8d6634511..461fb0a9da502b808348e14f32360fe19cce854c 100644 (file)
--- a/src/contextswitch.c
+++ b/src/contextswitch.c
if (status != 0) {
ERROR("contextswitch plugin: sysctlbyname "
"(vm.stats.sys.v_swtch) failed");
- return (-1);
+ return -1;
}
cs_submit(value);
if (fh == NULL) {
ERROR("contextswitch plugin: unable to open /proc/stat: %s",
sstrerror(errno, buffer, sizeof(buffer)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
char errbuf[1024];
ERROR("contextswitch plugin: perfstat_cpu_total: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
cs_submit(perfcputotal.pswitch);
diff --git a/src/cpu.c b/src/cpu.c
index c0bdd56f5fac741a082fdbe339699675202e9f1a..a5a136ecf7aedb81dc16f2e61a97be024215efde 100644 (file)
--- a/src/cpu.c
+++ b/src/cpu.c
else if (strcasecmp(key, "ReportNumCpu") == 0)
report_num_cpu = IS_TRUE(value) ? 1 : 0;
else
- return (-1);
+ return -1;
- return (0);
+ return 0;
} /* }}} int cpu_config */
static int init(void) {
"load information. "
"<https://collectd.org/bugs/22>");
cpu_list_len = 0;
- return (-1);
+ return -1;
}
if (status != KERN_SUCCESS) {
ERROR("cpu plugin: host_processors() failed with status %d.", (int)status);
cpu_list_len = 0;
- return (-1);
+ return -1;
}
INFO("cpu plugin: Found %i processor%s.", (int)cpu_list_len,
numcpu = 0;
if (kc == NULL)
- return (-1);
+ return -1;
/* Solaris doesn't count linear.. *sigh* */
for (numcpu = 0, ksp_chain = kc->kc_chain;
if (status == -1) {
char errbuf[1024];
WARNING("cpu plugin: sysctl: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* #endif CAN_USE_SYSCTL */
char errbuf[1024];
WARNING("cpu plugin: sysctlbyname(hw.ncpu): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
#ifdef HAVE_SYSCTL_KERN_CP_TIMES
char errbuf[1024];
WARNING("cpu plugin: sysctlbyname(kern.smp.maxcpus): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
#else
if (numcpu != 1)
/* nothing to initialize */
#endif /* HAVE_PERFSTAT */
- return (0);
+ return 0;
} /* int init */
static void submit_value(int cpu_num, int cpu_state, const char *type,
tmp = realloc(cpu_states, sz * sizeof(*cpu_states));
if (tmp == NULL) {
ERROR("cpu plugin: realloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
cpu_states = tmp;
tmp = cpu_states + cpu_states_num;
size_t index = ((cpu_num * COLLECTD_CPU_STATE_MAX) + state);
if (index >= cpu_states_num)
- return (NULL);
+ return NULL;
- return (&cpu_states[index]);
+ return &cpu_states[index];
} /* }}} cpu_state_t *get_cpu_state */
#if defined(HAVE_PERFSTAT) /* {{{ */
int status =
value_to_rate(&rate, (value_t){.derive = d}, DS_TYPE_DERIVE, now, conv);
if (status != 0)
- return (status);
+ return status;
sum_by_state[state] = rate;
if (state != COLLECTD_CPU_STATE_IDLE)
RATE_ADD(sum_by_state[COLLECTD_CPU_STATE_ACTIVE], sum_by_state[state]);
- return (0);
+ return 0;
}
#endif /* }}} HAVE_PERFSTAT */
value_t val = {.derive = d};
if (state >= COLLECTD_CPU_STATE_ACTIVE)
- return (EINVAL);
+ return EINVAL;
status = cpu_states_alloc(cpu_num);
if (status != 0)
- return (status);
+ return status;
if (global_cpu_num <= cpu_num)
global_cpu_num = cpu_num + 1;
status = value_to_rate(&rate, val, DS_TYPE_DERIVE, now, &s->conv);
if (status != 0)
- return (status);
+ return status;
s->rate = rate;
s->has_value = 1;
- return (0);
+ return 0;
} /* }}} int cpu_stage */
static int cpu_read(void) {
char errbuf[1024];
ERROR("cpu plugin: fopen (/proc/stat) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buf, 1024, fh) != NULL) {
static cpu_stat_t cs;
if (kc == NULL)
- return (-1);
+ return -1;
for (int cpu = 0; cpu < numcpu; cpu++) {
if (kstat_read(kc, ksp[cpu], &cs) == -1)
if (numcpu < 1) {
ERROR("cpu plugin: Could not determine number of "
"installed CPUs using sysctl(3).");
- return (-1);
+ return -1;
}
memset(cpuinfo, 0, sizeof(cpuinfo));
char errbuf[1024];
ERROR("cpu plugin: sysctl failed: %s.",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
} else
char errbuf[1024];
ERROR("cpu plugin: sysctl failed: %s.",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (int i = 0; i < CPUSTATES; i++) {
char errbuf[1024];
ERROR("cpu plugin: sysctlbyname failed: %s.",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (int i = 0; i < numcpu; i++) {
char errbuf[1024];
ERROR("cpu plugin: sysctlbyname failed: %s.",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
cpu_stage(0, COLLECTD_CPU_STATE_USER, (derive_t)cpuinfo[CP_USER], now);
if (cs == NULL) {
ERROR("cpu plugin: sg_get_cpu_stats failed.");
- return (-1);
+ return -1;
}
cpu_state(0, COLLECTD_CPU_STATE_IDLE, (derive_t)cs->idle);
char errbuf[1024];
WARNING("cpu plugin: perfstat_cpu: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (pnumcpu != numcpu || perfcpu == NULL) {
char errbuf[1024];
WARNING("cpu plugin: perfstat_cpu: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (int i = 0; i < cpus; i++) {
cpu_commit();
cpu_reset();
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/cpufreq.c b/src/cpufreq.c
index c3080cbff4167d4fedc11de788e7228d059b5be0..608e60e3a4c745377ced242c1e3d7a07910a5db6 100644 (file)
--- a/src/cpufreq.c
+++ b/src/cpufreq.c
if (num_cpu == 0)
plugin_unregister_read("cpufreq");
- return (0);
+ return 0;
} /* int cpufreq_init */
static void cpufreq_submit(int cpu_num, value_t value) {
cpufreq_submit(i, v);
}
- return (0);
+ return 0;
} /* int cpufreq_read */
void module_register(void) {
diff --git a/src/cpusleep.c b/src/cpusleep.c
index 62988fb0205f9e6c197ad4c86f39b00708bc6a1e..aa14cc12f8286060e388fd5be7ded5ba3400c7e3 100644 (file)
--- a/src/cpusleep.c
+++ b/src/cpusleep.c
struct timespec b, m;
if (clock_gettime(CLOCK_BOOTTIME, &b) < 0) {
ERROR("cpusleep plugin: clock_boottime failed");
- return (-1);
+ return -1;
}
if (clock_gettime(CLOCK_MONOTONIC, &m) < 0) {
ERROR("cpusleep plugin: clock_monotonic failed");
- return (-1);
+ return -1;
}
// to avoid false positives in counter overflow due to reboot,
cpusleep_submit(sleep);
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/csv.c b/src/csv.c
index c1759f5a364f09063b4a35b9cf3f58849404b6f1..e4c84f7fea9b5e4f264650a8a2a1ecebd520fc3d 100644 (file)
--- a/src/csv.c
+++ b/src/csv.c
status = ssnprintf(buffer, buffer_len, "%.3f", CDTIME_T_TO_DOUBLE(vl->time));
if ((status < 1) || (status >= buffer_len))
- return (-1);
+ return -1;
offset = status;
for (size_t i = 0; i < ds->ds_num; i++) {
(ds->ds[i].type != DS_TYPE_DERIVE) &&
(ds->ds[i].type != DS_TYPE_ABSOLUTE)) {
sfree(rates);
- return (-1);
+ return -1;
}
if (ds->ds[i].type == DS_TYPE_GAUGE) {
if (rates == NULL) {
WARNING("csv plugin: "
"uc_get_rate failed.");
- return (-1);
+ return -1;
}
status =
ssnprintf(buffer + offset, buffer_len - offset, ",%lf", rates[i]);
if ((status < 1) || (status >= (buffer_len - offset))) {
sfree(rates);
- return (-1);
+ return -1;
}
offset += status;
} /* for ds->ds_num */
sfree(rates);
- return (0);
+ return 0;
} /* int value_list_to_string */
static int value_list_to_filename(char *buffer, size_t buffer_size,
size_t len = strlen(datadir) + 1;
if (len >= ptr_size)
- return (ENOBUFS);
+ return ENOBUFS;
memcpy(ptr, datadir, len);
ptr[len - 1] = '/';
status = FORMAT_VL(ptr, ptr_size, vl);
if (status != 0)
- return (status);
+ return status;
/* Skip all the time formatting stuff when printing to STDOUT or
* STDERR. */
if (use_stdio)
- return (0);
+ return 0;
ptr_size -= strlen(ptr);
ptr += strlen(ptr);
/* "-2013-07-12" => 11 bytes */
if (ptr_size < 12) {
ERROR("csv plugin: Buffer too small.");
- return (ENOMEM);
+ return ENOMEM;
}
/* TODO: Find a way to minimize the calls to `localtime_r',
now = time(NULL);
if (localtime_r(&now, &struct_tm) == NULL) {
ERROR("csv plugin: localtime_r failed");
- return (-1);
+ return -1;
}
status = strftime(ptr, ptr_size, "-%Y-%m-%d", &struct_tm);
if (status == 0) /* yep, it returns zero on error. */
{
ERROR("csv plugin: strftime failed");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int value_list_to_filename */
static int csv_create_file(const char *filename, const data_set_t *ds) {
FILE *csv;
if (check_create_dir(filename))
- return (-1);
+ return -1;
csv = fopen(filename, "w");
if (csv == NULL) {
char errbuf[1024];
ERROR("csv plugin: fopen (%s) failed: %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
fprintf(csv, "epoch");
}
if (strcasecmp("stdout", value) == 0) {
use_stdio = 1;
- return (0);
+ return 0;
} else if (strcasecmp("stderr", value) == 0) {
use_stdio = 2;
- return (0);
+ return 0;
}
datadir = strdup(value);
if (datadir != NULL) {
else
store_rates = 0;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int csv_config */
static int csv_write(const data_set_t *ds, const value_list_t *vl,
status = value_list_to_filename(filename, sizeof(filename), vl);
if (status != 0)
- return (-1);
+ return -1;
DEBUG("csv plugin: csv_write: filename = %s;", filename);
if (value_list_to_string(values, sizeof(values), ds, vl) != 0)
- return (-1);
+ return -1;
if (use_stdio) {
escape_string(filename, sizeof(filename));
fprintf(use_stdio == 1 ? stdout : stderr, "PUTVAL %s interval=%.3f %s\n",
filename, CDTIME_T_TO_DOUBLE(vl->interval), values);
- return (0);
+ return 0;
}
if (stat(filename, &statbuf) == -1) {
if (errno == ENOENT) {
if (csv_create_file(filename, ds))
- return (-1);
+ return -1;
} else {
char errbuf[1024];
ERROR("stat(%s) failed: %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
} else if (!S_ISREG(statbuf.st_mode)) {
ERROR("stat(%s): Not a regular file!", filename);
- return (-1);
+ return -1;
}
csv = fopen(filename, "a");
char errbuf[1024];
ERROR("csv plugin: fopen (%s) failed: %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
csv_fd = fileno(csv);
ERROR("csv plugin: flock (%s) failed: %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
fclose(csv);
- return (-1);
+ return -1;
}
fprintf(csv, "%s\n", values);
* because the `FILE *' may need to flush a cache first */
fclose(csv);
- return (0);
+ return 0;
} /* int csv_write */
void module_register(void) {
diff --git a/src/curl.c b/src/curl.c
index 4906d9275462e26b23ca17a585de8ed88a773f60..808f2429ec4f0354f6f9cff31fd4e227d38882ce 100644 (file)
--- a/src/curl.c
+++ b/src/curl.c
len = size * nmemb;
if (len == 0)
- return (len);
+ return len;
wp = user_data;
if (wp == NULL)
- return (0);
+ return 0;
if ((wp->buffer_fill + len) >= wp->buffer_size) {
char *temp;
temp = realloc(wp->buffer, temp_size);
if (temp == NULL) {
ERROR("curl plugin: realloc failed.");
- return (0);
+ return 0;
}
wp->buffer = temp;
wp->buffer_size = temp_size;
wp->buffer_fill += len;
wp->buffer[wp->buffer_fill] = 0;
- return (len);
+ return len;
} /* }}} size_t cc_curl_callback */
static void cc_web_match_free(web_match_t *wm) /* {{{ */
struct curl_slist *temp = NULL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl plugin: `%s' needs exactly one string argument.", name);
- return (-1);
+ return -1;
}
temp = curl_slist_append(*dest, ci->values[0].value.string);
if (temp == NULL)
- return (-1);
+ return -1;
*dest = temp;
- return (0);
+ return 0;
} /* }}} int cc_config_append_string */
static int cc_config_add_match_dstype(int *dstype_ret, /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl plugin: `DSType' needs exactly one string argument.");
- return (-1);
+ return -1;
}
if (strncasecmp("Gauge", ci->values[0].value.string, strlen("Gauge")) == 0) {
if (dstype == 0) {
WARNING("curl plugin: `%s' is not a valid argument to `DSType'.",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
*dstype_ret = dstype;
- return (0);
+ return 0;
} /* }}} int cc_config_add_match_dstype */
static int cc_config_add_match(web_page_t *page, /* {{{ */
match = calloc(1, sizeof(*match));
if (match == NULL) {
ERROR("curl plugin: calloc failed.");
- return (-1);
+ return -1;
}
status = 0;
if (status != 0) {
cc_web_match_free(match);
- return (status);
+ return status;
}
match->match =
if (match->match == NULL) {
ERROR("curl plugin: match_create_simple failed.");
cc_web_match_free(match);
- return (-1);
+ return -1;
} else {
web_match_t *prev;
prev->next = match;
}
- return (0);
+ return 0;
} /* }}} int cc_config_add_match */
static int cc_page_init_curl(web_page_t *wp) /* {{{ */
wp->curl = curl_easy_init();
if (wp->curl == NULL) {
ERROR("curl plugin: curl_easy_init failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(wp->curl, CURLOPT_NOSIGNAL, 1L);
wp->credentials = malloc(credentials_size);
if (wp->credentials == NULL) {
ERROR("curl plugin: malloc failed.");
- return (-1);
+ return -1;
}
ssnprintf(wp->credentials, credentials_size, "%s:%s", wp->user,
(long)CDTIME_T_TO_MS(plugin_get_interval()));
#endif
- return (0);
+ return 0;
} /* }}} int cc_page_init_curl */
static int cc_config_add_page(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl plugin: `Page' blocks need exactly one string argument.");
- return (-1);
+ return -1;
}
page = calloc(1, sizeof(*page));
if (page == NULL) {
ERROR("curl plugin: calloc failed.");
- return (-1);
+ return -1;
}
page->url = NULL;
page->user = NULL;
if (page->instance == NULL) {
ERROR("curl plugin: strdup failed.");
sfree(page);
- return (-1);
+ return -1;
}
/* Process all children */
if (status != 0) {
cc_web_page_free(page);
- return (status);
+ return status;
}
/* Add the new page to the linked list */
prev->next = page;
}
- return (0);
+ return 0;
} /* }}} int cc_config_add_page */
static int cc_config(oconfig_item_t *ci) /* {{{ */
if ((success == 0) && (errors > 0)) {
ERROR("curl plugin: All statements failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cc_config */
static int cc_init(void) /* {{{ */
{
if (pages_g == NULL) {
INFO("curl plugin: No pages have been defined.");
- return (-1);
+ return -1;
}
curl_global_init(CURL_GLOBAL_SSL);
- return (0);
+ return 0;
} /* }}} int cc_init */
static void cc_submit(const web_page_t *wp, const web_match_t *wm, /* {{{ */
if (status != CURLE_OK) {
ERROR("curl plugin: curl_easy_perform failed with status %i: %s", status,
wp->curl_errbuf);
- return (-1);
+ return -1;
}
if (wp->response_time)
match_value_reset(mv);
} /* for (wm = wp->matches; wm != NULL; wm = wm->next) */
- return (0);
+ return 0;
} /* }}} int cc_read_page */
static int cc_read(void) /* {{{ */
for (web_page_t *wp = pages_g; wp != NULL; wp = wp->next)
cc_read_page(wp);
- return (0);
+ return 0;
} /* }}} int cc_read */
static int cc_shutdown(void) /* {{{ */
cc_web_page_free(pages_g);
pages_g = NULL;
- return (0);
+ return 0;
} /* }}} int cc_shutdown */
void module_register(void) {
diff --git a/src/curl_json.c b/src/curl_json.c
index 4d8677acee2866f1026ac9b711ef92188e01f250..9ec9f1e260d341a6088aa8d339ded7463ded7c2c 100644 (file)
--- a/src/curl_json.c
+++ b/src/curl_json.c
len = size * nmemb;
if (len == 0)
- return (len);
+ return len;
db = user_data;
if (db == NULL)
- return (0);
+ return 0;
status = yajl_parse(db->yajl, (unsigned char *)buf, len);
if (status == yajl_status_ok)
- return (len);
+ return len;
#if !HAVE_YAJL_V2
else if (status == yajl_status_insufficient_data)
- return (len);
+ return len;
#endif
unsigned char *msg =
/* jsonText = */ (unsigned char *)buf, (unsigned int)len);
ERROR("curl_json plugin: yajl_parse failed: %s", msg);
yajl_free_error(db->yajl, msg);
- return (0); /* abort write callback */
+ return 0; /* abort write callback */
} /* }}} size_t cj_curl_callback */
static int cj_get_type(cj_key_t *key) {
static int cj_cb_boolean(void *ctx, int boolVal) {
cj_cb_inc_array_index(ctx, /* update_key = */ 0);
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
static int cj_cb_null(void *ctx) {
cj_cb_inc_array_index(ctx, /* update_key = */ 0);
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
static int cj_cb_number(void *ctx, const char *number, yajl_len_t number_len) {
@@ -223,13 +223,13 @@ static int cj_cb_number(void *ctx, const char *number, yajl_len_t number_len) {
NOTICE("curl_json plugin: Found \"%s\", but the configuration expects"
" a map.",
buffer);
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
cj_cb_inc_array_index(ctx, /* update_key = */ 1);
key = db->state[db->depth].key;
if ((key == NULL) || !CJ_IS_KEY(key)) {
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
} else {
cj_cb_inc_array_index(ctx, /* update_key = */ 1);
@@ -239,11 +239,11 @@ static int cj_cb_number(void *ctx, const char *number, yajl_len_t number_len) {
status = parse_value(buffer, &vt, type);
if (status != 0) {
NOTICE("curl_json plugin: Unable to parse number: \"%s\"", buffer);
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
cj_submit(db, key, &vt);
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
} /* int cj_cb_number */
/* Queries the key-tree of the parent context for "in_name" and, if found,
db->state[db->depth].key = NULL;
}
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
static int cj_cb_string(void *ctx, const unsigned char *val, yajl_len_t len) {
/* Handle the string as if it was a number. */
- return (cj_cb_number(ctx, (const char *)val, len));
+ return cj_cb_number(ctx, (const char *)val, len);
} /* int cj_cb_string */
static int cj_cb_start(void *ctx) {
if (++db->depth >= YAJL_MAX_DEPTH) {
ERROR("curl_json plugin: %s depth exceeds max, aborting.",
db->url ? db->url : db->sock);
- return (CJ_CB_ABORT);
+ return CJ_CB_ABORT;
}
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
static int cj_cb_end(void *ctx) {
cj_t *db = (cj_t *)ctx;
db->state[db->depth].tree = NULL;
--db->depth;
- return (CJ_CB_CONTINUE);
+ return CJ_CB_CONTINUE;
}
static int cj_cb_start_map(void *ctx) {
/* Configuration handling functions {{{ */
static c_avl_tree_t *cj_avl_create(void) {
- return c_avl_create((int (*)(const void *, const void *))strcmp);
+ return c_avl_create((int(*)(const void *, const void *))strcmp);
}
static int cj_config_append_string(const char *name,
struct curl_slist *temp = NULL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl_json plugin: `%s' needs exactly one string argument.", name);
- return (-1);
+ return -1;
}
temp = curl_slist_append(*dest, ci->values[0].value.string);
if (temp == NULL)
- return (-1);
+ return -1;
*dest = temp;
- return (0);
+ return 0;
} /* }}} int cj_config_append_string */
static int cj_config_add_key(cj_t *db, /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl_json plugin: The `Key' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
key = calloc(1, sizeof(*key));
if (key == NULL) {
ERROR("curl_json plugin: calloc failed.");
- return (-1);
+ return -1;
}
key->magic = CJ_KEY_MAGIC;
status = cf_util_get_string(ci, &key->path);
if (status != 0) {
sfree(key);
- return (status);
+ return status;
}
} else {
ERROR("curl_json plugin: cj_config: "
"Invalid key: %s",
ci->key);
cj_key_free(key);
- return (-1);
+ return -1;
}
status = 0;
if (status != 0) {
cj_key_free(key);
- return (-1);
+ return -1;
}
if (key->type == NULL) {
WARNING("curl_json plugin: `Type' missing in `Key' block.");
cj_key_free(key);
- return (-1);
+ return -1;
}
/* store path in a tree that will match the json map structure, example:
if (strlen(name) == 0) {
ERROR("curl_json plugin: invalid key: %s", key->path);
cj_key_free(key);
- return (-1);
+ return -1;
}
c_avl_insert(tree, strdup(name), key);
- return (status);
+ return status;
} /* }}} int cj_config_add_key */
static int cj_init_curl(cj_t *db) /* {{{ */
db->curl = curl_easy_init();
if (db->curl == NULL) {
ERROR("curl_json plugin: curl_easy_init failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(db->curl, CURLOPT_NOSIGNAL, 1L);
db->credentials = malloc(credentials_size);
if (db->credentials == NULL) {
ERROR("curl_json plugin: malloc failed.");
- return (-1);
+ return -1;
}
ssnprintf(db->credentials, credentials_size, "%s:%s", db->user,
(long)CDTIME_T_TO_MS(plugin_get_interval()));
#endif
- return (0);
+ return 0;
} /* }}} int cj_init_curl */
static int cj_config_add_url(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl_json plugin: The `URL' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
db = calloc(1, sizeof(*db));
if (db == NULL) {
ERROR("curl_json plugin: calloc failed.");
- return (-1);
+ return -1;
}
db->timeout = -1;
"Invalid key: %s",
ci->key);
cj_free(db);
- return (-1);
+ return -1;
}
if (status != 0) {
sfree(db);
- return (status);
+ return status;
}
/* Fill the `cj_t' structure.. */
sfree(cb_name);
} else {
cj_free(db);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* }}} int cj_config_add_database */
if ((success == 0) && (errors > 0)) {
ERROR("curl_json plugin: All statements failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cj_config */
/* }}} End of configuration handling functions */
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0)
- return (-1);
+ return -1;
if (connect(fd, (struct sockaddr *)&sa_unix, sizeof(sa_unix)) < 0) {
ERROR("curl_json plugin: connect(%s) failed: %s",
(db->sock != NULL) ? db->sock : "<null>",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
- return (-1);
+ return -1;
}
ssize_t red;
(db->sock != NULL) ? db->sock : "<null>",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
- return (-1);
+ return -1;
}
if (!cj_curl_callback(buffer, red, 1, db))
break;
} while (red > 0);
close(fd);
- return (0);
+ return 0;
} /* }}} int cj_sock_perform */
static int cj_curl_perform(cj_t *db) /* {{{ */
if (status != CURLE_OK) {
ERROR("curl_json plugin: curl_easy_perform failed with status %i: %s (%s)",
status, db->curl_errbuf, url);
- return (-1);
+ return -1;
}
if (db->stats != NULL)
curl_stats_dispatch(db->stats, db->curl, cj_host(db), "curl_json",
ERROR("curl_json plugin: curl_easy_perform failed with "
"response code %ld (%s)",
rc, url);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cj_curl_perform */
static int cj_perform(cj_t *db) /* {{{ */
if (db->yajl == NULL) {
ERROR("curl_json plugin: yajl_alloc failed.");
db->yajl = yprev;
- return (-1);
+ return -1;
}
if (db->url)
if (status < 0) {
yajl_free(db->yajl);
db->yajl = yprev;
- return (-1);
+ return -1;
}
#if HAVE_YAJL_V2
yajl_free_error(db->yajl, errmsg);
yajl_free(db->yajl);
db->yajl = yprev;
- return (-1);
+ return -1;
}
yajl_free(db->yajl);
db->yajl = yprev;
- return (0);
+ return 0;
} /* }}} int cj_perform */
static int cj_read(user_data_t *ud) /* {{{ */
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("curl_json plugin: cj_read: Invalid user data.");
- return (-1);
+ return -1;
}
db = (cj_t *)ud->data;
/* Call this while collectd is still single-threaded to avoid
* initialization issues in libgcrypt. */
curl_global_init(CURL_GLOBAL_SSL);
- return (0);
+ return 0;
} /* }}} int cj_init */
void module_register(void) {
diff --git a/src/curl_xml.c b/src/curl_xml.c
index 1c2822771a0928a26e9124bf4800f744037319d4..a0dca05ea79c26ca9c10889af5529a6bfd44634e 100644 (file)
--- a/src/curl_xml.c
+++ b/src/curl_xml.c
if (db == NULL) {
ERROR("curl_xml plugin: cx_curl_callback: "
"user_data pointer is NULL.");
- return (0);
+ return 0;
}
if (len == 0)
- return (len);
+ return len;
if ((db->buffer_fill + len) >= db->buffer_size) {
char *temp;
temp = realloc(db->buffer, db->buffer_fill + len + 1);
if (temp == NULL) {
ERROR("curl_xml plugin: realloc failed.");
- return (0);
+ return 0;
}
db->buffer = temp;
db->buffer_size = db->buffer_fill + len + 1;
db->buffer_fill += len;
db->buffer[db->buffer_fill] = 0;
- return (len);
+ return len;
} /* }}} size_t cx_curl_callback */
static void cx_xpath_free(cx_xpath_t *xpath) /* {{{ */
struct curl_slist *temp = NULL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl_xml plugin: `%s' needs exactly one string argument.", name);
- return (-1);
+ return -1;
}
temp = curl_slist_append(*dest, ci->values[0].value.string);
if (temp == NULL)
- return (-1);
+ return -1;
*dest = temp;
- return (0);
+ return 0;
} /* }}} int cx_config_append_string */
static int cx_check_type(const data_set_t *ds, cx_xpath_t *xpath) /* {{{ */
{
if (!ds) {
WARNING("curl_xml plugin: DataSet `%s' not defined.", xpath->type);
- return (-1);
+ return -1;
}
if (ds->ds_num != xpath->values_len) {
WARNING("curl_xml plugin: DataSet `%s' requires %zu values, but config "
"talks about %zu",
xpath->type, ds->ds_num, xpath->values_len);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} cx_check_type */
static xmlXPathObjectPtr
{
if (node->type == XML_TEXT_NODE || node->type == XML_ATTRIBUTE_NODE ||
node->type == XML_ELEMENT_NODE)
- return (0);
+ return 0;
WARNING("curl_xml plugin: "
"Node \"%s\" doesn't seem to be a text node. Skipping...",
values_node_obj =
cx_evaluate_xpath(xpath_ctx, BAD_CAST xpath->values[index].path);
if (values_node_obj == NULL)
- return (-1); /* Error already logged. */
+ return -1; /* Error already logged. */
values_node = values_node_obj->nodesetval;
tmp_size = (values_node) ? values_node->nodeNr : 0;
"Skipping...",
xpath->values[index].path);
xmlXPathFreeObject(values_node_obj);
- return (-1);
+ return -1;
}
if (tmp_size > 1) {
"only one node. Skipping...",
xpath->values[index].path);
xmlXPathFreeObject(values_node_obj);
- return (-1);
+ return -1;
}
/* ignoring the element if other than textnode/attribute*/
"only text/attribute node which is not the case. Skipping...",
xpath->values[index].path);
xmlXPathFreeObject(values_node_obj);
- return (-1);
+ return -1;
}
node_value = (char *)xmlNodeGetContent(values_node->nodeTab[0]);
/* We have reached here which means that
* we have got something to work */
- return (0);
+ return 0;
} /* }}} int cx_handle_single_value_xpath */
static int cx_handle_all_value_xpaths(xmlXPathContextPtr xpath_ctx, /* {{{ */
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)
- return (-1); /* An error has been printed. */
+ return -1; /* An error has been printed. */
} /* for (i = 0; i < xpath->values_len; i++) */
plugin_dispatch_values(vl);
vl->values = NULL;
- return (0);
+ return 0;
} /* }}} int cx_handle_all_value_xpaths */
static int cx_handle_instance_xpath(xmlXPathContextPtr xpath_ctx, /* {{{ */
"Base-XPath %s is a table (more than one result was returned), "
"but no instance-XPath has been defined.",
xpath->path);
- return (-1);
+ return -1;
}
/* instance has to be an xpath expression */
instance_node_obj = cx_evaluate_xpath(xpath_ctx, BAD_CAST xpath->instance);
if (instance_node_obj == NULL)
- return (-1); /* error is logged already */
+ return -1; /* error is logged already */
instance_node = instance_node_obj->nodesetval;
tmp_size = (instance_node) ? instance_node->nodeNr : 0;
"any of the nodes. Skipping the node.",
xpath->instance);
xmlXPathFreeObject(instance_node_obj);
- return (-1);
+ return -1;
}
if (tmp_size > 1) {
"to return only one text node. Skipping the node.",
xpath->instance);
xmlXPathFreeObject(instance_node_obj);
- return (-1);
+ return -1;
}
/* ignoring the element if other than textnode/attribute */
"which is not the case. Skipping the node.",
xpath->instance);
xmlXPathFreeObject(instance_node_obj);
- return (-1);
+ return -1;
}
} /* if (xpath->instance != NULL) */
* somewhere inside this structure. */
xmlXPathFreeObject(instance_node_obj);
- return (0);
+ return 0;
} /* }}} int cx_handle_instance_xpath */
static int cx_handle_base_xpath(char const *plugin_instance, /* {{{ */
/* free up the allocated memory */
xmlXPathFreeObject(base_node_obj);
- return (0);
+ return 0;
} /* }}} cx_handle_base_xpath */
static int cx_handle_parsed_xml(xmlDocPtr doc, /* {{{ */
doc = xmlParseDoc(xml);
if (doc == NULL) {
ERROR("curl_xml plugin: Failed to parse the xml document - %s", xml);
- return (-1);
+ return -1;
}
xpath_ctx = xmlXPathNewContext(doc);
if (xpath_ctx == NULL) {
ERROR("curl_xml plugin: Failed to create the xml context");
xmlFreeDoc(doc);
- return (-1);
+ return -1;
}
for (size_t i = 0; i < db->namespaces_num; i++) {
ns->prefix, ns->url);
xmlXPathFreeContext(xpath_ctx);
xmlFreeDoc(doc);
- return (status);
+ return status;
}
}
if (status != CURLE_OK) {
ERROR("curl_xml plugin: curl_easy_perform failed with status %i: %s (%s)",
status, db->curl_errbuf, url);
- return (-1);
+ return -1;
}
if (db->stats != NULL)
curl_stats_dispatch(db->stats, db->curl, cx_host(db), "curl_xml",
ERROR(
"curl_xml plugin: curl_easy_perform failed with response code %ld (%s)",
rc, url);
- return (-1);
+ return -1;
}
ptr = db->buffer;
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("curl_xml plugin: cx_read: Invalid user data.");
- return (-1);
+ return -1;
}
db = (cx_t *)ud->data;
@@ -654,13 +654,13 @@ static int cx_config_add_values(const char *name, cx_xpath_t *xpath, /* {{{ */
oconfig_item_t *ci) {
if (ci->values_num < 1) {
WARNING("curl_xml plugin: `ValuesFrom' needs at least one argument.");
- return (-1);
+ return -1;
}
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.");
- return (-1);
+ return -1;
}
sfree(xpath->values);
xpath->values_len = 0;
xpath->values = malloc(sizeof(cx_values_t) * ci->values_num);
if (xpath->values == NULL)
- return (-1);
+ return -1;
xpath->values_len = (size_t)ci->values_num;
/* populate cx_values_t structure */
sizeof(xpath->values[i].path));
}
- return (0);
+ return 0;
} /* }}} cx_config_add_values */
static int cx_config_add_xpath(cx_t *db, oconfig_item_t *ci) /* {{{ */
xpath = calloc(1, sizeof(*xpath));
if (xpath == NULL) {
ERROR("curl_xml plugin: calloc failed.");
- return (-1);
+ return -1;
}
status = cf_util_get_string(ci, &xpath->path);
if (status != 0) {
cx_xpath_free(xpath);
- return (status);
+ return status;
}
/* error out if xpath->path is an empty string */
ERROR("curl_xml plugin: invalid xpath. "
"xpath value can't be an empty string");
cx_xpath_free(xpath);
- return (-1);
+ return -1;
}
status = 0;
if (db->list == NULL) {
ERROR("curl_xml plugin: list creation failed.");
cx_xpath_free(xpath);
- return (-1);
+ return -1;
}
}
if (name == NULL) {
ERROR("curl_xml plugin: strdup failed.");
cx_xpath_free(xpath);
- return (-1);
+ return -1;
}
le = llentry_create(name, xpath);
ERROR("curl_xml plugin: llentry_create failed.");
cx_xpath_free(xpath);
sfree(name);
- return (-1);
+ return -1;
}
llist_append(db->list, le);
- return (0);
+ return 0;
} /* }}} int cx_config_add_xpath */
static int cx_config_add_namespace(cx_t *db, /* {{{ */
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
WARNING("curl_xml plugin: The `Namespace' option "
"needs exactly two string arguments.");
- return (EINVAL);
+ return EINVAL;
}
ns = realloc(db->namespaces,
sizeof(*db->namespaces) * (db->namespaces_num + 1));
if (ns == NULL) {
ERROR("curl_xml plugin: realloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
db->namespaces = ns;
ns = db->namespaces + db->namespaces_num;
sfree(ns->prefix);
sfree(ns->url);
ERROR("curl_xml plugin: strdup failed.");
- return (ENOMEM);
+ return ENOMEM;
}
db->namespaces_num++;
- return (0);
+ return 0;
} /* }}} int cx_config_add_namespace */
/* Initialize db->curl */
db->curl = curl_easy_init();
if (db->curl == NULL) {
ERROR("curl_xml plugin: curl_easy_init failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(db->curl, CURLOPT_NOSIGNAL, 1L);
db->credentials = malloc(credentials_size);
if (db->credentials == NULL) {
ERROR("curl_xml plugin: malloc failed.");
- return (-1);
+ return -1;
}
ssnprintf(db->credentials, credentials_size, "%s:%s", db->user,
(long)CDTIME_T_TO_MS(plugin_get_interval()));
#endif
- return (0);
+ return 0;
} /* }}} int cx_init_curl */
static int cx_config_add_url(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("curl_xml plugin: The `URL' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
db = calloc(1, sizeof(*db));
if (db == NULL) {
ERROR("curl_xml plugin: calloc failed.");
- return (-1);
+ return -1;
}
db->timeout = -1;
status = cf_util_get_string(ci, &db->url);
if (status != 0) {
sfree(db);
- return (status);
+ return status;
}
} else {
ERROR("curl_xml plugin: cx_config: "
"Invalid key: %s",
ci->key);
cx_free(db);
- return (-1);
+ return -1;
}
/* Fill the `cx_t' structure.. */
sfree(cb_name);
} else {
cx_free(db);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cx_config_add_url */
/* }}} End of configuration handling functions */
if ((success == 0) && (errors > 0)) {
ERROR("curl_xml plugin: All statements failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cx_config */
static int cx_init(void) /* {{{ */
/* Call this while collectd is still single-threaded to avoid
* initialization issues in libgcrypt. */
curl_global_init(CURL_GLOBAL_SSL);
- return (0);
+ return 0;
} /* }}} int cx_init */
void module_register(void) {
diff --git a/src/daemon/collectd.c b/src/daemon/collectd.c
index 6b7c413635631f2d10626e0def0fb6f28f9e3a12..2edfa3774ca763067d5eefcbfa7fde6791c99b60 100644 (file)
--- a/src/daemon/collectd.c
+++ b/src/daemon/collectd.c
str = global_option_get("Hostname");
if ((str != NULL) && (str[0] != 0)) {
sstrncpy(hostname_g, str, sizeof(hostname_g));
- return (0);
+ return 0;
}
if (gethostname(hostname_g, sizeof(hostname_g)) != 0) {
fprintf(stderr, "`gethostname' failed and no "
"hostname was configured.\n");
- return (-1);
+ return -1;
}
str = global_option_get("FQDNLookup");
if (IS_FALSE(str))
- return (0);
+ return 0;
struct addrinfo ai_hints = {.ai_flags = AI_CANONNAME};
"name. Please fix the network "
"configuration.",
hostname_g);
- return (-1);
+ return -1;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
}
freeaddrinfo(ai_list);
- return (0);
+ return 0;
} /* int init_hostname */
static int init_global_variables(void) {
if (timeout_g <= 1) {
fprintf(stderr, "Cannot set the timeout to a correct value.\n"
"Please check your settings.\n");
- return (-1);
+ return -1;
}
DEBUG("timeout_g = %i;", timeout_g);
if (init_hostname() != 0)
- return (-1);
+ return -1;
DEBUG("hostname_g = %s;", hostname_g);
- return (0);
+ return 0;
} /* int init_global_variables */
static int change_basedir(const char *orig_dir) {
if (dir == NULL) {
char errbuf[1024];
ERROR("strdup failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
dirlen = strlen(dir);
if (dirlen == 0) {
free(dir);
- return (-1);
+ return -1;
}
status = chdir(dir);
if (status == 0) {
free(dir);
- return (0);
+ return 0;
} else if (errno != ENOENT) {
char errbuf[1024];
ERROR("change_basedir: chdir (%s): %s", dir,
sstrerror(errno, errbuf, sizeof(errbuf)));
free(dir);
- return (-1);
+ return -1;
}
status = mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO);
ERROR("change_basedir: mkdir (%s): %s", dir,
sstrerror(errno, errbuf, sizeof(errbuf)));
free(dir);
- return (-1);
+ return -1;
}
status = chdir(dir);
ERROR("change_basedir: chdir (%s): %s", dir,
sstrerror(errno, errbuf, sizeof(errbuf)));
free(dir);
- return (-1);
+ return -1;
}
free(dir);
- return (0);
+ return 0;
} /* static int change_basedir (char *dir) */
#if HAVE_LIBKSTAT
#endif
)) {
ERROR("sg_init: %s", sg_str_error(sg_get_error()));
- return (-1);
+ return -1;
}
if (sg_drop_privileges()) {
ERROR("sg_drop_privileges: %s", sg_str_error(sg_get_error()));
- return (-1);
+ return -1;
}
#endif
if (errno != EINTR) {
char errbuf[1024];
ERROR("nanosleep failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
} /* while (loop == 0) */
- return (0);
+ return 0;
} /* int do_loop */
static int do_shutdown(void) {
if ((fh = fopen(file, "w")) == NULL) {
char errbuf[1024];
ERROR("fopen (%s): %s", file, sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
fprintf(fh, "%i\n", (int)getpid());
fclose(fh);
- return (0);
+ return 0;
} /* static int pidfile_create (const char *file) */
static int pidfile_remove(void) {
if (file == NULL)
return 0;
- return (unlink(file));
+ return unlink(file);
} /* static int pidfile_remove (const char *file) */
#endif /* COLLECT_DAEMON */
if (cf_read(configfile)) {
fprintf(stderr, "Error: Reading the config file failed!\n"
"Read the logs for details.\n");
- return (1);
+ return 1;
}
/*
if ((basedir = global_option_get("BaseDir")) == NULL) {
fprintf(stderr,
"Don't have a basedir to use. This should not happen. Ever.");
- return (1);
+ return 1;
} else if (change_basedir(basedir)) {
fprintf(stderr, "Error: Unable to change to directory `%s'.\n", basedir);
- return (1);
+ return 1;
}
/*
exit(EXIT_FAILURE);
if (test_config)
- return (0);
+ return 0;
#if COLLECT_DAEMON
/*
/* error */
char errbuf[1024];
fprintf(stderr, "fork: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
} else if (pid != 0) {
/* parent */
/* printf ("Running (PID %i)\n", pid); */
- return (0);
+ return 0;
}
/* Detach from session */
if (status != 0) {
ERROR("Error: Could not connect `STDIN' to `/dev/null' (status %d)",
status);
- return (1);
+ return 1;
}
status = dup(0);
if (status != 1) {
ERROR("Error: Could not connect `STDOUT' to `/dev/null' (status %d)",
status);
- return (1);
+ return 1;
}
status = dup(0);
if (status != 2) {
ERROR("Error: Could not connect `STDERR' to `/dev/null', (status %d)",
status);
- return (1);
+ return 1;
}
} /* if (daemonize) */
#endif /* COLLECT_DAEMON */
char errbuf[1024];
ERROR("Error: Failed to install a signal handler for signal INT: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
struct sigaction sig_term_action = {.sa_handler = sig_term_handler};
char errbuf[1024];
ERROR("Error: Failed to install a signal handler for signal TERM: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
struct sigaction sig_usr1_action = {.sa_handler = sig_usr1_handler};
char errbuf[1024];
ERROR("Error: Failed to install a signal handler for signal USR1: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
/*
pidfile_remove();
#endif /* COLLECT_DAEMON */
- return (exit_status);
+ return exit_status;
} /* int main */
diff --git a/src/daemon/collectd.h b/src/daemon/collectd.h
index 38ffd0f61e55726d8487af2f37f4057559293ca4..01d484ee082fa3b05edad7da08acf33f2a1f2c83 100644 (file)
--- a/src/daemon/collectd.h
+++ b/src/daemon/collectd.h
/* Only enable __attribute__() for compilers known to support it. */
#if !defined(__clang__) && !defined(__GNUC__)
-#if !defined(__attribute__)
#define __attribute__(x) /**/
#endif
-#endif
#if defined(COLLECT_DEBUG) && COLLECT_DEBUG && defined(__GNUC__) && __GNUC__
#undef strcpy
diff --git a/src/daemon/common.c b/src/daemon/common.c
index a167122cd9dcf6412ebc297fb902b3336a2465e3..d9c83483fd933be389bc841df1801d582a9832c1 100644 (file)
--- a/src/daemon/common.c
+++ b/src/daemon/common.c
strncpy(dest, src, n);
dest[n - 1] = '\0';
- return (dest);
+ return dest;
} /* char *sstrncpy */
int ssnprintf(char *dest, size_t n, const char *format, ...) {
dest[n - 1] = '\0';
va_end(ap);
- return (ret);
+ return ret;
} /* int ssnprintf */
char *ssnprintf_alloc(char const *format, ...) /* {{{ */
status = vsnprintf(static_buffer, sizeof(static_buffer), format, ap);
va_end(ap);
if (status < 0)
- return (NULL);
+ return NULL;
/* "status" does not include the null byte. */
alloc_buffer_size = (size_t)(status + 1);
if (alloc_buffer_size <= sizeof(static_buffer))
- return (strdup(static_buffer));
+ return strdup(static_buffer);
/* Allocate a buffer large enough to hold the string. */
alloc_buffer = calloc(1, alloc_buffer_size);
if (alloc_buffer == NULL)
- return (NULL);
+ return NULL;
/* Print again into this new buffer. */
va_start(ap, format);
va_end(ap);
if (status < 0) {
sfree(alloc_buffer);
- return (NULL);
+ return NULL;
}
- return (alloc_buffer);
+ return alloc_buffer;
} /* }}} char *ssnprintf_alloc */
char *sstrdup(const char *s) {
size_t sz;
if (s == NULL)
- return (NULL);
+ return NULL;
/* Do not use `strdup' here, because it's not specified in POSIX. It's
* ``only'' an XSI extension. */
}
memcpy(r, s, sz);
- return (r);
+ return r;
} /* char *sstrdup */
/* Even though Posix requires "strerror_r" to return an "int",
}
#endif /* STRERROR_R_CHAR_P */
- return (buf);
+ return buf;
} /* char *sstrerror */
void *smalloc(size_t size) {
exit(3);
}
- return (r);
+ return r;
} /* void *smalloc */
#if 0
continue;
if (status < 0)
- return (status);
+ return status;
if (status == 0) {
DEBUG("Received EOF from fd %i. "
"Closing fd and returning error.",
fd);
close(fd);
- return (-1);
+ return -1;
}
assert((0 > status) || (nleft >= (size_t)status));
ptr = ptr + ((size_t)status);
}
- return (0);
+ return 0;
}
ssize_t swrite(int fd, const void *buf, size_t count) {
ptr = ptr + ((size_t)status);
}
- return (0);
+ return 0;
}
int strsplit(char *string, char **fields, size_t size) {
break;
}
- return ((int)i);
+ return (int)i;
}
int strjoin(char *buffer, size_t buffer_size, char **fields, size_t fields_num,
if (((fields_num != 0) && (fields == NULL)) ||
((buffer_size != 0) && (buffer == NULL)))
- return (-EINVAL);
+ return -EINVAL;
if (buffer != NULL)
buffer[0] = 0;
/* Check if we need to escape at all first */
temp = strpbrk(buffer, " \t\"\\");
if (temp == NULL)
- return (0);
+ return 0;
if (buffer_size < 3)
- return (EINVAL);
+ return EINVAL;
temp = calloc(1, buffer_size);
if (temp == NULL)
- return (ENOMEM);
+ return ENOMEM;
temp[0] = '"';
j = 1;
sstrncpy(buffer, temp, buffer_size);
sfree(temp);
- return (0);
+ return 0;
} /* int escape_string */
int strunescape(char *buf, size_t buf_len) {
ERROR("string unescape: backslash found at end of string.");
/* Ensure null-byte at the end of the buffer. */
buf[i] = 0;
- return (-1);
+ return -1;
}
switch (buf[i + 1]) {
memmove(buf + i + 1, buf + i + 2, buf_len - i - 2);
buf[buf_len - 1] = 0;
}
- return (0);
+ return 0;
} /* int strunescape */
size_t strstripnewline(char *buffer) {
buffer[buffer_len] = 0;
}
- return (buffer_len);
+ return buffer_len;
} /* size_t strstripnewline */
int escape_slashes(char *buffer, size_t buffer_size) {
if (buffer_len <= 1) {
if (strcmp("/", buffer) == 0) {
if (buffer_size < 5)
- return (-1);
+ return -1;
sstrncpy(buffer, "root", buffer_size);
}
- return (0);
+ return 0;
}
/* Move one to the left */
buffer[i] = '_';
}
- return (0);
+ return 0;
} /* int escape_slashes */
void replace_special(char *buffer, size_t buffer_size) {
@@ -520,7 +520,7 @@ int timeval_cmp(struct timeval tv0, struct timeval tv1, struct timeval *delta) {
delta->tv_sec = 0;
delta->tv_usec = 0;
}
- return (0);
+ return 0;
}
if ((tv0.tv_sec < tv1.tv_sec) ||
@@ -548,7 +548,7 @@ int timeval_cmp(struct timeval tv0, struct timeval tv1, struct timeval *delta) {
assert((delta == NULL) ||
((0 <= delta->tv_usec) && (delta->tv_usec < 1000000)));
- return (status);
+ return status;
} /* int timeval_cmp */
int check_create_dir(const char *file_orig) {
* Sanity checks first
*/
if (file_orig == NULL)
- return (-1);
+ return -1;
if ((len = strlen(file_orig)) < 1)
- return (-1);
+ return -1;
else if (len >= sizeof(file_copy))
- return (-1);
+ return -1;
/*
* If `file_orig' ends in a slash the last component is a directory,
ERROR("Cowardly refusing to create a directory that "
"begins with a `.' (dot): `%s'",
file_orig);
- return (-2);
+ return -2;
}
/*
if (strjoin(dir + path_is_absolute, (size_t)(dir_len - path_is_absolute),
fields, (size_t)(i + 1), "/") < 0) {
ERROR("strjoin failed: `%s', component #%i", file_orig, i);
- return (-1);
+ return -1;
}
while (42) {
char errbuf[1024];
ERROR("check_create_dir: mkdir (%s): %s", dir,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
} else {
char errbuf[1024];
ERROR("check_create_dir: stat (%s): %s", dir,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
} else if (!S_ISDIR(statbuf.st_mode)) {
ERROR("check_create_dir: `%s' exists but is not "
"a directory!",
dir);
- return (-1);
+ return -1;
}
break;
}
}
- return (0);
+ return 0;
} /* check_create_dir */
#ifdef HAVE_LIBKSTAT
*ksp_ptr = NULL;
if (kc == NULL)
- return (-1);
+ return -1;
ssnprintf(ident, sizeof(ident), "%s,%i,%s", module, instance, name);
*ksp_ptr = kstat_lookup(kc, module, instance, name);
if (*ksp_ptr == NULL) {
ERROR("get_kstat: Cound not find kstat %s", ident);
- return (-1);
+ return -1;
}
if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) {
ERROR("get_kstat: kstat %s has wrong type", ident);
*ksp_ptr = NULL;
- return (-1);
+ return -1;
}
#ifdef assert
if (kstat_read(kc, *ksp_ptr, NULL) == -1) {
ERROR("get_kstat: kstat %s could not be read", ident);
- return (-1);
+ return -1;
}
if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) {
ERROR("get_kstat: kstat %s has wrong type", ident);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
long long get_kstat_value(kstat_t *ksp, char *name) {
if (ksp == NULL) {
ERROR("get_kstat_value (\"%s\"): ksp is NULL.", name);
- return (-1LL);
+ return -1LL;
} else if (ksp->ks_type != KSTAT_TYPE_NAMED) {
ERROR("get_kstat_value (\"%s\"): ksp->ks_type (%#x) "
"is not KSTAT_TYPE_NAMED (%#x).",
name, (unsigned int)ksp->ks_type, (unsigned int)KSTAT_TYPE_NAMED);
- return (-1LL);
+ return -1LL;
}
if ((kn = (kstat_named_t *)kstat_data_lookup(ksp, name)) == NULL)
- return (-1LL);
+ return -1LL;
if (kn->data_type == KSTAT_DATA_INT32)
retval = (long long)kn->value.i32;
else
WARNING("get_kstat_value: Not a numeric value: %s", name);
- return (retval);
+ return retval;
}
#endif /* HAVE_LIBKSTAT */
#ifndef HAVE_HTONLL
unsigned long long ntohll(unsigned long long n) {
#if BYTE_ORDER == BIG_ENDIAN
- return (n);
+ return n;
#else
return (((unsigned long long)ntohl(n)) << 32) + ntohl(n >> 32);
#endif
unsigned long long htonll(unsigned long long n) {
#if BYTE_ORDER == BIG_ENDIAN
- return (n);
+ return n;
#else
return (((unsigned long long)htonl(n)) << 32) + htonl(n >> 32);
#endif
if ((ret.byte[0] == 0x00) && (ret.byte[1] == 0x00) && (ret.byte[2] == 0x00) &&
(ret.byte[3] == 0x00) && (ret.byte[4] == 0x00) && (ret.byte[5] == 0x00) &&
(ret.byte[6] == 0xf8) && (ret.byte[7] == 0x7f)) {
- return (NAN);
+ return NAN;
} else {
uint64_t tmp;
tmp = ret.integer;
ret.integer = FP_CONVERT(tmp);
- return (ret.floating);
+ return ret.floating;
}
} /* double ntohd */
ret.byte[4] = ret.byte[5] = 0x00;
ret.byte[6] = 0xf8;
ret.byte[7] = 0x7f;
- return (ret.floating);
+ return ret.floating;
} else {
uint64_t tmp;
ret.floating = d;
tmp = FP_CONVERT(ret.integer);
ret.integer = tmp;
- return (ret.floating);
+ return ret.floating;
}
} /* double htond */
#endif /* FP_LAYOUT_NEED_ENDIANFLIP || FP_LAYOUT_NEED_INTSWAP */
do { \
size_t l = strlen(str); \
if (l >= buffer_size) \
- return (ENOBUFS); \
+ return ENOBUFS; \
memcpy(buffer, (str), l); \
buffer += l; \
buffer_size -= l; \
buffer[0] = 0;
#undef APPEND
- return (0);
+ return 0;
} /* int format_name */
int format_values(char *ret, size_t ret_len, /* {{{ */
status = ssnprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
- return (-1); \
+ return -1; \
} else if (((size_t)status) >= (ret_len - offset)) { \
sfree(rates); \
- return (-1); \
+ return -1; \
} else \
offset += ((size_t)status); \
} while (0)
rates = uc_get_rate(ds, vl);
if (rates == NULL) {
WARNING("format_values: uc_get_rate failed.");
- return (-1);
+ return -1;
}
BUFFER_ADD(":" GAUGE_FORMAT, rates[i]);
} else if (ds->ds[i].type == DS_TYPE_COUNTER)
else {
ERROR("format_values: Unknown data source type: %i", ds->ds[i].type);
sfree(rates);
- return (-1);
+ return -1;
}
} /* for ds->ds_num */
#undef BUFFER_ADD
sfree(rates);
- return (0);
+ return 0;
} /* }}} int format_values */
int parse_identifier(char *str, char **ret_host, char **ret_plugin,
hostname = str;
if (hostname == NULL)
- return (-1);
+ return -1;
plugin = strchr(hostname, '/');
if (plugin == NULL)
- return (-1);
+ return -1;
*plugin = '\0';
plugin++;
type = strchr(plugin, '/');
if (type == NULL) {
if (default_host == NULL)
- return (-1);
+ return -1;
/* else: no host specified; use default */
type = plugin;
plugin = hostname;
*ret_plugin_instance = plugin_instance;
*ret_type = type;
*ret_type_instance = type_instance;
- return (0);
+ return 0;
} /* int parse_identifier */
int parse_identifier_vl(const char *str, value_list_t *vl) /* {{{ */
int status;
if ((str == NULL) || (vl == NULL))
- return (EINVAL);
+ return EINVAL;
sstrncpy(str_copy, str, sizeof(str_copy));
&type_instance,
/* default_host = */ NULL);
if (status != 0)
- return (status);
+ return status;
sstrncpy(vl->host, host, sizeof(vl->host));
sstrncpy(vl->plugin, plugin, sizeof(vl->plugin));
sstrncpy(vl->type_instance, (type_instance != NULL) ? type_instance : "",
sizeof(vl->type_instance));
- return (0);
+ return 0;
} /* }}} int parse_identifier_vl */
int parse_value(const char *value_orig, value_t *ret_value, int ds_type) {
size_t value_len;
if (value_orig == NULL)
- return (EINVAL);
+ return EINVAL;
value = strdup(value_orig);
if (value == NULL)
- return (ENOMEM);
+ return ENOMEM;
value_len = strlen(value);
while ((value_len > 0) && isspace((int)value[value_len - 1])) {
|| (endptr == ptr) /* Invalid string */
|| (endptr == NULL) /* This should not happen */
|| (*endptr != 0)) /* Trailing chars */
- return (-1);
+ return -1;
vl->time = DOUBLE_TO_CDTIME_T(tmp);
}
} /* while (strtok_r) */
if ((ptr != NULL) || (i == 0))
- return (-1);
- return (0);
+ return -1;
+ return 0;
} /* int parse_values */
int parse_value_file(char const *path, value_t *ret_value, int ds_type) {
fh = fopen(path, "r");
if (fh == NULL)
- return (-1);
+ return -1;
if (fgets(buffer, sizeof(buffer), fh) == NULL) {
fclose(fh);
- return (-1);
+ return -1;
}
fclose(fh);
@@ -1185,7 +1185,7 @@ int getpwnam_r(const char *name, struct passwd *pwbuf, char *buf, size_t buflen,
pthread_mutex_unlock(&getpwnam_r_lock);
- return (status);
+ return status;
} /* int getpwnam_r */
#endif /* !HAVE_GETPWNAM_R */
if (type_instance != NULL)
sstrncpy(n->type_instance, type_instance, sizeof(n->type_instance));
- return (0);
+ return 0;
} /* int notification_init */
int walk_directory(const char *dir, dirwalk_callback_f callback,
closedir(dh);
if ((success == 0) && (failure > 0))
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
ssize_t read_file_contents(const char *filename, char *buf, size_t bufsize) {
fh = fopen(filename, "r");
if (fh == NULL)
- return (-1);
+ return -1;
ret = (ssize_t)fread(buf, 1, bufsize, fh);
if ((ret == 0) && (ferror(fh) != 0)) {
}
fclose(fh);
- return (ret);
+ return ret;
}
counter_t counter_diff(counter_t old_value, counter_t new_value) {
diff = new_value - old_value;
}
- return (diff);
+ return diff;
} /* counter_t counter_diff */
int rate_to_value(value_t *ret_value, gauge_t rate, /* {{{ */
state->last_time = t;
*ret_value = state->last_value;
- return (0);
+ return 0;
}
/* Counter and absolute can't handle negative rates. Reset "last time"
if ((rate < 0.0) &&
((ds_type == DS_TYPE_COUNTER) || (ds_type == DS_TYPE_ABSOLUTE))) {
memset(state, 0, sizeof(*state));
- return (EINVAL);
+ return EINVAL;
}
/* Another invalid state: The time is not increasing. */
if (t <= state->last_time) {
memset(state, 0, sizeof(*state));
- return (EINVAL);
+ return EINVAL;
}
delta_t = t - state->last_time;
}
state->last_time = t;
- return (EAGAIN);
+ return EAGAIN;
} /* }}} */
if (ds_type == DS_TYPE_DERIVE) {
state->last_time = t;
*ret_value = state->last_value;
- return (0);
+ return 0;
} /* }}} value_t rate_to_value */
int value_to_rate(gauge_t *ret_rate, /* {{{ */
/* Another invalid state: The time is not increasing. */
if (t <= state->last_time) {
memset(state, 0, sizeof(*state));
- return (EINVAL);
+ return EINVAL;
}
interval = CDTIME_T_TO_DOUBLE(t - state->last_time);
if (state->last_time == 0) {
state->last_value = value;
state->last_time = t;
- return (EAGAIN);
+ return EAGAIN;
}
switch (ds_type) {
state->last_value = value;
state->last_time = t;
- return (0);
+ return 0;
} /* }}} value_t rate_to_value */
int service_name_to_port_number(const char *service_name) {
int service_number;
if (service_name == NULL)
- return (-1);
+ return -1;
struct addrinfo ai_hints = {.ai_family = AF_UNSPEC};
if (status != 0) {
ERROR("service_name_to_port_number: getaddrinfo failed: %s",
gai_strerror(status));
- return (-1);
+ return -1;
}
service_number = -1;
freeaddrinfo(ai_list);
if ((service_number > 0) && (service_number <= 65535))
- return (service_number);
- return (-1);
+ return service_number;
+ return -1;
} /* int service_name_to_port_number */
void set_sock_opts(int sockfd) /* {{{ */
char *endptr;
if ((string == NULL) || (ret_value == NULL))
- return (EINVAL);
+ return EINVAL;
errno = 0;
endptr = NULL;
tmp = (derive_t)strtoll(string, &endptr, /* base = */ 0);
if ((endptr == string) || (errno != 0))
- return (-1);
+ return -1;
*ret_value = tmp;
- return (0);
+ return 0;
} /* }}} int strtoderive */
int strtogauge(const char *string, gauge_t *ret_value) /* {{{ */
char *endptr = NULL;
if ((string == NULL) || (ret_value == NULL))
- return (EINVAL);
+ return EINVAL;
errno = 0;
endptr = NULL;
tmp = (gauge_t)strtod(string, &endptr);
if (errno != 0)
- return (errno);
+ return errno;
else if ((endptr == NULL) || (*endptr != 0))
- return (EINVAL);
+ return EINVAL;
*ret_value = tmp;
- return (0);
+ return 0;
} /* }}} int strtogauge */
int strarray_add(char ***ret_array, size_t *ret_array_len,
size_t array_len = *ret_array_len;
if (str == NULL)
- return (EINVAL);
+ return EINVAL;
array = realloc(*ret_array, (array_len + 1) * sizeof(*array));
if (array == NULL)
- return (ENOMEM);
+ return ENOMEM;
*ret_array = array;
array[array_len] = strdup(str);
if (array[array_len] == NULL)
- return (ENOMEM);
+ return ENOMEM;
array_len++;
*ret_array_len = array_len;
- return (0);
+ return 0;
} /* }}} int strarray_add */
void strarray_free(char **array, size_t array_len) /* {{{ */
cap_flag_value_t cap_flag_value;
if (!CAP_IS_SUPPORTED(cap_value))
- return (-1);
+ return -1;
if (!(cap = cap_get_proc())) {
ERROR("check_capability: cap_get_proc failed.");
- return (-1);
+ return -1;
}
if (cap_get_flag(cap, cap_value, CAP_EFFECTIVE, &cap_flag_value) < 0) {
ERROR("check_capability: cap_get_flag failed.");
cap_free(cap);
- return (-1);
+ return -1;
}
cap_free(cap);
- return (cap_flag_value != CAP_SET);
+ return cap_flag_value != CAP_SET;
} /* }}} int check_capability */
#else
int check_capability(__attribute__((unused)) int arg) /* {{{ */
{
WARNING("check_capability: unsupported capability implementation. "
"Some plugin(s) may require elevated privileges to work properly.");
- return (0);
+ return 0;
} /* }}} int check_capability */
#endif /* HAVE_CAPABILITY */
index f18d9fdad41e14c7dc79f69d97f1f0533875ce3f..5b577d4534679a83470130fe4053f860451f134c 100644 (file)
--- a/src/daemon/common_test.c
+++ b/src/daemon/common_test.c
EXPECT_EQ_STR("collect", ptr);
OK(buffer[3] == buffer[12]);
- return (0);
+ return 0;
}
DEF_TEST(ssnprintf) {
EXPECT_EQ_STR("collect", ptr);
OK(buffer[3] == buffer[12]);
- return (0);
+ return 0;
}
DEF_TEST(sstrdup) {
ptr = sstrdup(NULL);
OK(ptr == NULL);
- return (0);
+ return 0;
}
DEF_TEST(strsplit) {
status = strsplit(buffer, fields, 8);
OK(status == 0);
- return (0);
+ return 0;
}
DEF_TEST(strjoin) {
/* use (NULL, 0) to determine required buffer size. */
EXPECT_EQ_INT(3, strjoin(NULL, 0, (char *[]){"a", "b"}, 2, "-"));
- return (0);
+ return 0;
}
DEF_TEST(escape_slashes) {
status = strunescape(buffer, sizeof(buffer));
OK(status != 0);
EXPECT_EQ_STR("\tbackslash end", buffer);
- return (0);
+ return 0;
/* Backslash at buffer end */
strncpy(buffer, "\\t3\\56", sizeof(buffer));
OK(buffer[5] == '6');
OK(buffer[6] == '7');
- return (0);
+ return 0;
}
DEF_TEST(parse_values) {
EXPECT_EQ_DOUBLE(cases[i].value, vl.values[0].gauge);
}
- return (0);
+ return 0;
}
DEF_TEST(value_to_rate) {
index 654cc49b9b408108b174fe24020dc3fe3d4a6d32..5594bb7ab5b3c808317ae5ab45dfa6dc7be71730 100644 (file)
--- a/src/daemon/configfile.c
+++ b/src/daemon/configfile.c
cf_callback_t *cf_cb;
if (type == NULL)
- return (NULL);
+ return NULL;
for (cf_cb = first_callback; cf_cb != NULL; cf_cb = cf_cb->next)
if (strcasecmp(cf_cb->type, type) == 0)
break;
- return (cf_cb);
+ return cf_cb;
}
static int cf_dispatch(const char *type, const char *orig_key,
int i = 0;
if (orig_key == NULL)
- return (EINVAL);
+ return EINVAL;
DEBUG("type = %s, key = %s, value = %s", ESCAPE_NULL(type), orig_key,
ESCAPE_NULL(orig_value));
"the plugin isn't loaded or didn't register "
"a configuration callback.",
type);
- return (-1);
+ return -1;
}
if ((key = strdup(orig_key)) == NULL)
- return (1);
+ return 1;
if ((value = strdup(orig_value)) == NULL) {
free(key);
- return (2);
+ return 2;
}
ret = -1;
free(key);
free(value);
- return (ret);
+ return ret;
} /* int cf_dispatch */
static int dispatch_global_option(const oconfig_item_t *ci) {
if (ci->values_num != 1)
- return (-1);
+ return -1;
if (ci->values[0].type == OCONFIG_TYPE_STRING)
- return (global_option_set(ci->key, ci->values[0].value.string, 0));
+ return global_option_set(ci->key, ci->values[0].value.string, 0);
else if (ci->values[0].type == OCONFIG_TYPE_NUMBER) {
char tmp[128];
ssnprintf(tmp, sizeof(tmp), "%lf", ci->values[0].value.number);
- return (global_option_set(ci->key, tmp, 0));
+ return global_option_set(ci->key, tmp, 0);
} else if (ci->values[0].type == OCONFIG_TYPE_BOOLEAN) {
if (ci->values[0].value.boolean)
- return (global_option_set(ci->key, "true", 0));
+ return global_option_set(ci->key, "true", 0);
else
- return (global_option_set(ci->key, "false", 0));
+ return global_option_set(ci->key, "false", 0);
}
- return (-1);
+ return -1;
} /* int dispatch_global_option */
static int dispatch_value_typesdb(oconfig_item_t *ci) {
if (ci->values_num < 1) {
ERROR("configfile: `TypesDB' needs at least one argument.");
- return (-1);
+ return -1;
}
for (int i = 0; i < ci->values_num; ++i) {
read_types_list(ci->values[i].value.string);
}
- return (0);
+ return 0;
} /* int dispatch_value_typesdb */
static int dispatch_value_plugindir(oconfig_item_t *ci) {
assert(strcasecmp(ci->key, "PluginDir") == 0);
if (ci->values_num != 1)
- return (-1);
+ return -1;
if (ci->values[0].type != OCONFIG_TYPE_STRING)
- return (-1);
+ return -1;
plugin_set_dir(ci->values[0].value.string);
- return (0);
+ return 0;
}
static int dispatch_loadplugin(oconfig_item_t *ci) {
assert(strcasecmp(ci->key, "LoadPlugin") == 0);
if (ci->values_num != 1)
- return (-1);
+ return -1;
if (ci->values[0].type != OCONFIG_TYPE_STRING)
- return (-1);
+ return -1;
name = ci->values[0].value.string;
if (strcmp("libvirt", name) == 0)
/* reset to the "global" context */
plugin_set_ctx(old_ctx);
- return (ret_val);
+ return ret_val;
} /* int dispatch_value_loadplugin */
static int dispatch_value_plugin(const char *plugin, oconfig_item_t *ci) {
ci->values[i].value.boolean ? "true" : "false");
if ((status < 0) || (status >= buffer_free))
- return (-1);
+ return -1;
buffer_free -= status;
buffer_ptr += status;
}
/* skip the initial space */
buffer_ptr = buffer + 1;
- return (cf_dispatch(plugin, ci->key, buffer_ptr));
+ return cf_dispatch(plugin, ci->key, buffer_ptr);
} /* int dispatch_value_plugin */
static int dispatch_value(oconfig_item_t *ci) {
break;
}
- return (ret);
+ return ret;
} /* int dispatch_value */
static int dispatch_block_plugin(oconfig_item_t *ci) {
const char *name;
if (strcasecmp(ci->key, "Plugin") != 0)
- return (-1);
+ return -1;
if (ci->values_num < 1)
- return (-1);
+ return -1;
if (ci->values[0].type != OCONFIG_TYPE_STRING)
- return (-1);
+ return -1;
name = ci->values[0].value.string;
if (strcmp("libvirt", name) == 0) {
ERROR("Automatically loading plugin \"%s\" failed "
"with status %i.",
name, status);
- return (status);
+ return status;
}
}
old_ctx = plugin_set_ctx(cb->ctx);
ret_val = (cb->callback(ci));
plugin_set_ctx(old_ctx);
- return (ret_val);
+ return ret_val;
}
}
}
}
- return (0);
+ return 0;
}
static int dispatch_block(oconfig_item_t *ci) {
if (strcasecmp(ci->key, "LoadPlugin") == 0)
- return (dispatch_loadplugin(ci));
+ return dispatch_loadplugin(ci);
else if (strcasecmp(ci->key, "Plugin") == 0)
- return (dispatch_block_plugin(ci));
+ return dispatch_block_plugin(ci);
else if (strcasecmp(ci->key, "Chain") == 0)
- return (fc_configure(ci));
+ return fc_configure(ci);
- return (0);
+ return 0;
}
static int cf_ci_replace_child(oconfig_item_t *dst, oconfig_item_t *src,
* all children. */
if (dst->children_num + src->children_num - 1 == 0) {
dst->children_num = 0;
- return (0);
+ return 0;
}
temp =
(dst->children_num + src->children_num - 1));
if (temp == NULL) {
ERROR("configfile: realloc failed.");
- return (-1);
+ return -1;
}
dst->children = temp;
/* Update the number of children. */
dst->children_num += (src->children_num - 1);
- return (0);
+ return 0;
} /* int cf_ci_replace_child */
static int cf_ci_append_children(oconfig_item_t *dst, oconfig_item_t *src) {
oconfig_item_t *temp;
if ((src == NULL) || (src->children_num == 0))
- return (0);
+ return 0;
temp = realloc(dst->children, sizeof(oconfig_item_t) *
(dst->children_num + src->children_num));
if (temp == NULL) {
ERROR("configfile: realloc failed.");
- return (-1);
+ return -1;
}
dst->children = temp;
sizeof(oconfig_item_t) * src->children_num);
dst->children_num += src->children_num;
- return (0);
+ return 0;
} /* int cf_ci_append_children */
#define CF_MAX_DEPTH 8
sfree(pattern);
if (new == NULL)
- return (-1);
+ return -1;
/* Now replace the i'th child in `root' with `new'. */
if (cf_ci_replace_child(root, new, i) < 0) {
sfree(new->values);
sfree(new);
- return (-1);
+ return -1;
}
/* ... and go back to the new i'th child. */
sfree(new);
} /* for (i = 0; i < root->children_num; i++) */
- return (0);
+ return 0;
} /* int cf_include_all */
static oconfig_item_t *cf_read_file(const char *file, const char *pattern,
"does not match pattern `%s'.",
filename, pattern);
free(tmp);
- return (NULL);
+ return NULL;
}
free(tmp);
root = oconfig_parse_file(file);
if (root == NULL) {
ERROR("configfile: Cannot read file `%s'.", file);
- return (NULL);
+ return NULL;
}
status = cf_include_all(root, depth);
if (status != 0) {
oconfig_free(root);
- return (NULL);
+ return NULL;
}
- return (root);
+ return root;
} /* oconfig_item_t *cf_read_file */
static int cf_compare_string(const void *p1, const void *p2) {
char errbuf[1024];
ERROR("configfile: opendir failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (NULL);
+ return NULL;
}
root = calloc(1, sizeof(*root));
if (root == NULL) {
ERROR("configfile: calloc failed.");
closedir(dh);
- return (NULL);
+ return NULL;
}
while ((de = readdir(dh)) != NULL) {
free(filenames[i]);
free(filenames);
free(root);
- return (NULL);
+ return NULL;
}
++filenames_num;
free(filenames[i]);
free(filenames);
free(root);
- return (NULL);
+ return NULL;
}
filenames = tmp;
if (filenames == NULL) {
closedir(dh);
- return (root);
+ return root;
}
qsort((void *)filenames, filenames_num, sizeof(*filenames),
closedir(dh);
free(filenames);
- return (root);
+ return root;
} /* oconfig_item_t *cf_read_dir */
/*
ERROR("configfile: Not including `%s' because the maximum "
"nesting depth has been reached.",
path);
- return (NULL);
+ return NULL;
}
status = wordexp(path, &we, WRDE_NOCMD);
if (status != 0) {
ERROR("configfile: wordexp (%s) failed.", path);
- return (NULL);
+ return NULL;
}
root = calloc(1, sizeof(*root));
if (root == NULL) {
ERROR("configfile: calloc failed.");
- return (NULL);
+ return NULL;
}
/* wordexp() might return a sorted list already. That's not
if (temp == NULL) {
oconfig_free(root);
- return (NULL);
+ return NULL;
}
cf_ci_append_children(root, temp);
wordfree(&we);
- return (root);
+ return root;
} /* oconfig_item_t *cf_read_generic */
/* #endif HAVE_WORDEXP_H */
ERROR("configfile: Not including `%s' because the maximum "
"nesting depth has been reached.",
path);
- return (NULL);
+ return NULL;
}
status = stat(path, &statbuf);
char errbuf[1024];
ERROR("configfile: stat (%s) failed: %s", path,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (NULL);
+ return NULL;
}
if (S_ISREG(statbuf.st_mode))
- return (cf_read_file(path, pattern, depth));
+ return cf_read_file(path, pattern, depth);
else if (S_ISDIR(statbuf.st_mode))
- return (cf_read_dir(path, pattern, depth));
+ return cf_read_dir(path, pattern, depth);
ERROR("configfile: %s is neither a file nor a directory.", path);
- return (NULL);
+ return NULL;
} /* oconfig_item_t *cf_read_generic */
#endif /* !HAVE_WORDEXP_H */
@@ -841,14 +841,14 @@ int global_option_set(const char *option, const char *value, _Bool from_cli) {
if (i >= cf_global_options_num) {
ERROR("configfile: Cannot set unknown global option `%s'.", option);
- return (-1);
+ return -1;
}
if (cf_global_options[i].from_cli && (!from_cli)) {
DEBUG("configfile: Ignoring %s `%s' option because "
"it was overriden by a command-line option.",
option, value);
- return (0);
+ return 0;
}
sfree(cf_global_options[i].value);
cf_global_options[i].from_cli = from_cli;
- return (0);
+ return 0;
}
const char *global_option_get(const char *option) {
if (i >= cf_global_options_num) {
ERROR("configfile: Cannot get unknown global option `%s'.", option);
- return (NULL);
+ return NULL;
}
- return ((cf_global_options[i].value != NULL) ? cf_global_options[i].value
- : cf_global_options[i].def);
+ return (cf_global_options[i].value != NULL) ? cf_global_options[i].value : cf_global_options[i].def;
} /* char *global_option_get */
long global_option_get_long(const char *option, long default_value) {
str = global_option_get(option);
if (NULL == str)
- return (default_value);
+ return default_value;
errno = 0;
value = strtol(str, /* endptr = */ NULL, /* base = */ 0);
if (errno != 0)
- return (default_value);
+ return default_value;
- return (value);
+ return value;
} /* char *global_option_get_long */
cdtime_t global_option_get_time(const char *name, cdtime_t def) /* {{{ */
optstr = global_option_get(name);
if (optstr == NULL)
- return (def);
+ return def;
errno = 0;
v = strtod(optstr, &endptr);
if ((endptr == NULL) || (*endptr != 0) || (errno != 0))
- return (def);
+ return def;
else if (v <= 0.0)
- return (def);
+ return def;
- return (DOUBLE_TO_CDTIME_T(v));
+ return DOUBLE_TO_CDTIME_T(v);
} /* }}} cdtime_t global_option_get_time */
cdtime_t cf_get_default_interval(void) {
- return (global_option_get_time(
- "Interval", DOUBLE_TO_CDTIME_T(COLLECTD_DEFAULT_INTERVAL)));
+ return global_option_get_time("Interval",
+ DOUBLE_TO_CDTIME_T(COLLECTD_DEFAULT_INTERVAL));
}
void cf_unregister(const char *type) {
@@ -974,12 +973,12 @@ int cf_register_complex(const char *type, int (*callback)(oconfig_item_t *)) {
new = malloc(sizeof(*new));
if (new == NULL)
- return (-1);
+ return -1;
new->type = strdup(type);
if (new->type == NULL) {
sfree(new);
- return (-1);
+ return -1;
}
new->callback = callback;
last->next = new;
}
- return (0);
+ return 0;
} /* int cf_register_complex */
int cf_read(const char *filename) {
conf = cf_read_generic(filename, /* pattern = */ NULL, /* depth = */ 0);
if (conf == NULL) {
ERROR("Unable to read config file %s.", filename);
- return (-1);
+ return -1;
} else if (conf->children_num == 0) {
ERROR("Configuration file %s is empty.", filename);
oconfig_free(conf);
- return (-1);
+ return -1;
}
for (int i = 0; i < conf->children_num; i++) {
@@ -1045,18 +1044,18 @@ int cf_util_get_string(const oconfig_item_t *ci, char **ret_string) /* {{{ */
ERROR("cf_util_get_string: The %s option requires "
"exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
string = strdup(ci->values[0].value.string);
if (string == NULL)
- return (-1);
+ return -1;
if (*ret_string != NULL)
sfree(*ret_string);
*ret_string = string;
- return (0);
+ return 0;
} /* }}} int cf_util_get_string */
/* Assures the config option is a string and copies it to the provided buffer.
@@ -1064,67 +1063,67 @@ int cf_util_get_string(const oconfig_item_t *ci, char **ret_string) /* {{{ */
int cf_util_get_string_buffer(const oconfig_item_t *ci, char *buffer, /* {{{ */
size_t buffer_size) {
if ((ci == NULL) || (buffer == NULL) || (buffer_size < 1))
- return (EINVAL);
+ return EINVAL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
ERROR("cf_util_get_string_buffer: The %s option requires "
"exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
strncpy(buffer, ci->values[0].value.string, buffer_size);
buffer[buffer_size - 1] = 0;
- return (0);
+ return 0;
} /* }}} int cf_util_get_string_buffer */
/* Assures the config option is a number and returns it as an int. */
int cf_util_get_int(const oconfig_item_t *ci, int *ret_value) /* {{{ */
{
if ((ci == NULL) || (ret_value == NULL))
- return (EINVAL);
+ return EINVAL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) {
ERROR("cf_util_get_int: The %s option requires "
"exactly one numeric argument.",
ci->key);
- return (-1);
+ return -1;
}
*ret_value = (int)ci->values[0].value.number;
- return (0);
+ return 0;
} /* }}} int cf_util_get_int */
int cf_util_get_double(const oconfig_item_t *ci, double *ret_value) /* {{{ */
{
if ((ci == NULL) || (ret_value == NULL))
- return (EINVAL);
+ return EINVAL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) {
ERROR("cf_util_get_double: The %s option requires "
"exactly one numeric argument.",
ci->key);
- return (-1);
+ return -1;
}
*ret_value = ci->values[0].value.number;
- return (0);
+ return 0;
} /* }}} int cf_util_get_double */
int cf_util_get_boolean(const oconfig_item_t *ci, _Bool *ret_bool) /* {{{ */
{
if ((ci == NULL) || (ret_bool == NULL))
- return (EINVAL);
+ return EINVAL;
if ((ci->values_num != 1) || ((ci->values[0].type != OCONFIG_TYPE_BOOLEAN) &&
(ci->values[0].type != OCONFIG_TYPE_STRING))) {
ERROR("cf_util_get_boolean: The %s option requires "
"exactly one boolean argument.",
ci->key);
- return (-1);
+ return -1;
}
switch (ci->values[0].type) {
@@ -1145,12 +1144,12 @@ int cf_util_get_boolean(const oconfig_item_t *ci, _Bool *ret_bool) /* {{{ */
ERROR("cf_util_get_boolean: Cannot parse string value `%s' of the `%s' "
"option as a boolean value.",
ci->values[0].value.string, ci->key);
- return (-1);
+ return -1;
}
break;
}
- return (0);
+ return 0;
} /* }}} int cf_util_get_boolean */
int cf_util_get_flag(const oconfig_item_t *ci, /* {{{ */
_Bool b;
if (ret_value == NULL)
- return (EINVAL);
+ return EINVAL;
b = 0;
status = cf_util_get_boolean(ci, &b);
if (status != 0)
- return (status);
+ return status;
if (b) {
*ret_value |= flag;
*ret_value &= ~flag;
}
- return (0);
+ return 0;
} /* }}} int cf_util_get_flag */
/* Assures that the config option is a string or a number if the correct range
ERROR("cf_util_get_port_number: The \"%s\" option requires "
"exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].type == OCONFIG_TYPE_STRING)
- return (service_name_to_port_number(ci->values[0].value.string));
+ return service_name_to_port_number(ci->values[0].value.string);
assert(ci->values[0].type == OCONFIG_TYPE_NUMBER);
tmp = (int)(ci->values[0].value.number + 0.5);
"you specified, %i, is not in the valid "
"range of 1-65535.",
ci->key, tmp);
- return (-1);
+ return -1;
}
- return (tmp);
+ return tmp;
} /* }}} int cf_util_get_port_number */
int cf_util_get_service(const oconfig_item_t *ci, char **ret_string) /* {{{ */
@@ -1219,11 +1218,11 @@ int cf_util_get_service(const oconfig_item_t *ci, char **ret_string) /* {{{ */
ERROR("cf_util_get_service: The %s option requires exactly "
"one argument.",
ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].type == OCONFIG_TYPE_STRING)
- return (cf_util_get_string(ci, ret_string));
+ return cf_util_get_string(ci, ret_string);
if (ci->values[0].type != OCONFIG_TYPE_NUMBER) {
ERROR("cf_util_get_service: The %s option requires "
"exactly one string or numeric argument.",
@@ -1233,48 +1232,48 @@ int cf_util_get_service(const oconfig_item_t *ci, char **ret_string) /* {{{ */
port = 0;
status = cf_util_get_int(ci, &port);
if (status != 0)
- return (status);
+ return status;
else if ((port < 1) || (port > 65535)) {
ERROR("cf_util_get_service: The port number given "
"for the %s option is out of "
"range (%i).",
ci->key, port);
- return (-1);
+ return -1;
}
service = malloc(6);
if (service == NULL) {
ERROR("cf_util_get_service: Out of memory.");
- return (-1);
+ return -1;
}
ssnprintf(service, 6, "%i", port);
sfree(*ret_string);
*ret_string = service;
- return (0);
+ return 0;
} /* }}} int cf_util_get_service */
int cf_util_get_cdtime(const oconfig_item_t *ci, cdtime_t *ret_value) /* {{{ */
{
if ((ci == NULL) || (ret_value == NULL))
- return (EINVAL);
+ return EINVAL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) {
ERROR("cf_util_get_cdtime: The %s option requires "
"exactly one numeric argument.",
ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].value.number < 0.0) {
ERROR("cf_util_get_cdtime: The numeric argument of the %s "
"option must not be negative.",
ci->key);
- return (-1);
+ return -1;
}
*ret_value = DOUBLE_TO_CDTIME_T(ci->values[0].value.number);
- return (0);
+ return 0;
} /* }}} int cf_util_get_cdtime */
index f21ea32b56ff4f8926b42c95f0c9ca5e189bc1e1..5a2d64729ae953ba753492bc00e082b0a4570df3 100644 (file)
char *dest;
if (orig == NULL)
- return (NULL);
+ return NULL;
sz = strlen(orig) + 1;
dest = malloc(sz);
if (dest == NULL)
- return (NULL);
+ return NULL;
memcpy(dest, orig, sz);
- return (dest);
+ return dest;
} /* }}} char *fc_strdup */
/*
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("Filter subsystem: `Match' blocks require "
"exactly one string argument.");
- return (-1);
+ return -1;
}
ptr = match_list_head;
WARNING("Filter subsystem: Cannot find a \"%s\" match. "
"Did you load the appropriate plugin?",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
m = calloc(1, sizeof(*m));
if (m == NULL) {
ERROR("fc_config_add_match: calloc failed.");
- return (-1);
+ return -1;
}
sstrncpy(m->name, ptr->name, sizeof(m->name));
if (status != 0) {
WARNING("Filter subsystem: Failed to create a %s match.", m->name);
fc_free_matches(m);
- return (-1);
+ return -1;
}
}
*matches_head = m;
}
- return (0);
+ return 0;
} /* }}} int fc_config_add_match */
static int fc_config_add_target(fc_target_t **targets_head, /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("Filter subsystem: `Target' blocks require "
"exactly one string argument.");
- return (-1);
+ return -1;
}
ptr = target_list_head;
WARNING("Filter subsystem: Cannot find a \"%s\" target. "
"Did you load the appropriate plugin?",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
t = calloc(1, sizeof(*t));
if (t == NULL) {
ERROR("fc_config_add_target: calloc failed.");
- return (-1);
+ return -1;
}
sstrncpy(t->name, ptr->name, sizeof(t->name));
if (status != 0) {
WARNING("Filter subsystem: Failed to create a %s target.", t->name);
fc_free_targets(t);
- return (-1);
+ return -1;
}
} else {
t->user_data = NULL;
*targets_head = t;
}
- return (0);
+ return 0;
} /* }}} int fc_config_add_target */
static int fc_config_add_rule(fc_chain_t *chain, /* {{{ */
if (ci->values_num > 1) {
WARNING("Filter subsystem: `Rule' blocks have at most one argument.");
- return (-1);
+ return -1;
} else if ((ci->values_num == 1) &&
(ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("Filter subsystem: `Rule' blocks expect one string argument "
"or no argument at all.");
- return (-1);
+ return -1;
}
rule = calloc(1, sizeof(*rule));
if (rule == NULL) {
ERROR("fc_config_add_rule: calloc failed.");
- return (-1);
+ return -1;
}
if (ci->values_num == 1) {
if (status != 0) {
fc_free_rules(rule);
- return (-1);
+ return -1;
}
if (chain->rules != NULL) {
chain->rules = rule;
}
- return (0);
+ return 0;
} /* }}} int fc_config_add_rule */
static int fc_config_add_chain(const oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("Filter subsystem: <Chain> blocks require exactly one "
"string argument.");
- return (-1);
+ return -1;
}
if (chain_list_head != NULL) {
chain = calloc(1, sizeof(*chain));
if (chain == NULL) {
ERROR("fc_config_add_chain: calloc failed.");
- return (-1);
+ return -1;
}
sstrncpy(chain->name, ci->values[0].value.string, sizeof(chain->name));
}
if (status != 0) {
fc_free_chains(chain);
- return (-1);
+ return -1;
}
if (chain_list_head != NULL) {
if (!new_chain)
- return (0);
+ return 0;
fc_chain_t *ptr;
chain_list_head = chain;
}
- return (0);
+ return 0;
} /* }}} int fc_config_add_chain */
/*
if (ci->children_num != 1) {
ERROR("Filter subsystem: The built-in target `jump' needs exactly "
"one `Chain' argument!");
- return (-1);
+ return -1;
}
ci_chain = ci->children;
ERROR("Filter subsystem: The built-in target `jump' does not "
"support the configuration option `%s'.",
ci_chain->key);
- return (-1);
+ return -1;
}
if ((ci_chain->values_num != 1) ||
(ci_chain->values[0].type != OCONFIG_TYPE_STRING)) {
ERROR("Filter subsystem: Built-in target `jump': The `Chain' option "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
*user_data = fc_strdup(ci_chain->values[0].value.string);
if (*user_data == NULL) {
ERROR("fc_bit_jump_create: fc_strdup failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int fc_bit_jump_create */
static int fc_bit_jump_destroy(void **user_data) /* {{{ */
*user_data = NULL;
}
- return (0);
+ return 0;
} /* }}} int fc_bit_jump_destroy */
static int fc_bit_jump_invoke(const data_set_t *ds, /* {{{ */
ERROR("Filter subsystem: Built-in target `jump': There is no chain "
"named `%s'.",
chain_name);
- return (-1);
+ return -1;
}
status = fc_process_chain(ds, vl, chain);
if (status < 0)
- return (status);
+ return status;
else if (status == FC_TARGET_STOP)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
else
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int fc_bit_jump_invoke */
static int
value_list_t __attribute__((unused)) * vl,
notification_meta_t __attribute__((unused)) * *meta,
void __attribute__((unused)) * *user_data) {
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int fc_bit_stop_invoke */
static int
value_list_t __attribute__((unused)) * vl,
notification_meta_t __attribute__((unused)) * *meta,
void __attribute__((unused)) * *user_data) {
- return (FC_TARGET_RETURN);
+ return FC_TARGET_RETURN;
} /* }}} int fc_bit_return_invoke */
static int fc_bit_write_create(const oconfig_item_t *ci, /* {{{ */
*user_data = plugin_list;
- return (0);
+ return 0;
} /* }}} int fc_bit_write_create */
static int fc_bit_write_destroy(void **user_data) /* {{{ */
fc_writer_t *plugin_list;
if ((user_data == NULL) || (*user_data == NULL))
- return (0);
+ return 0;
plugin_list = *user_data;
free(plugin_list[i].plugin);
free(plugin_list);
- return (0);
+ return 0;
} /* }}} int fc_bit_write_destroy */
static int fc_bit_write_invoke(const data_set_t *ds, /* {{{ */
} /* for (i = 0; plugin_list[i] != NULL; i++) */
}
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int fc_bit_write_invoke */
static int fc_init_once(void) /* {{{ */
target_proc_t tproc = {0};
if (done != 0)
- return (0);
+ return 0;
tproc.create = fc_bit_jump_create;
tproc.destroy = fc_bit_jump_destroy;
fc_register_target("write", tproc);
done++;
- return (0);
+ return 0;
} /* }}} int fc_init_once */
/*
m = calloc(1, sizeof(*m));
if (m == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
sstrncpy(m->name, name, sizeof(m->name));
memcpy(&m->proc, &proc, sizeof(m->proc));
ptr->next = m;
}
- return (0);
+ return 0;
} /* }}} int fc_register_match */
/* Add a target to list of available targets. */
t = calloc(1, sizeof(*t));
if (t == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
sstrncpy(t->name, name, sizeof(t->name));
memcpy(&t->proc, &proc, sizeof(t->proc));
ptr->next = t;
}
- return (0);
+ return 0;
} /* }}} int fc_register_target */
fc_chain_t *fc_chain_get_by_name(const char *chain_name) /* {{{ */
{
if (chain_name == NULL)
- return (NULL);
+ return NULL;
for (fc_chain_t *chain = chain_list_head; chain != NULL; chain = chain->next)
if (strcasecmp(chain_name, chain->name) == 0)
- return (chain);
+ return chain;
- return (NULL);
+ return NULL;
} /* }}} int fc_chain_get_by_name */
int fc_process_chain(const data_set_t *ds, value_list_t *vl, /* {{{ */
int status = FC_TARGET_CONTINUE;
if (chain == NULL)
- return (-1);
+ return -1;
DEBUG("fc_process_chain (chain = %s);", chain->name);
} /* for (rule) */
if ((status == FC_TARGET_STOP) || (status == FC_TARGET_RETURN))
- return (status);
+ return status;
DEBUG("fc_process_chain (%s): Executing the default targets.", chain->name);
chain->name, target->name,
(status == FC_TARGET_STOP) ? "stop" : "return");
if (status == FC_TARGET_STOP)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
else
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
}
DEBUG("fc_process_chain (%s): Signaling `continue' at end of chain.",
chain->name);
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int fc_process_chain */
/* Iterate over all rules in the chain and execute all targets for which all
int fc_default_action(const data_set_t *ds, value_list_t *vl) /* {{{ */
{
/* FIXME: Pass the meta-data to match targets here (when implemented). */
- return (fc_bit_write_invoke(ds, vl,
- /* meta = */ NULL, /* user_data = */ NULL));
+ return fc_bit_write_invoke(ds, vl, NULL, NULL);
} /* }}} int fc_default_action */
int fc_configure(const oconfig_item_t *ci) /* {{{ */
fc_init_once();
if (ci == NULL)
- return (-EINVAL);
+ return -EINVAL;
if (strcasecmp("Chain", ci->key) == 0)
- return (fc_config_add_chain(ci));
+ return fc_config_add_chain(ci);
WARNING("Filter subsystem: Unknown top level config option `%s'.", ci->key);
- return (-1);
+ return -1;
} /* }}} int fc_configure */
diff --git a/src/daemon/meta_data.c b/src/daemon/meta_data.c
index 3ac5370621005d3507207c4287caf2a8225a502f..502ca1086074ff1ab597b75a33a7dd1dec96b36a 100644 (file)
--- a/src/daemon/meta_data.c
+++ b/src/daemon/meta_data.c
char *dest;
if (orig == NULL)
- return (NULL);
+ return NULL;
sz = strlen(orig) + 1;
dest = malloc(sz);
if (dest == NULL)
- return (NULL);
+ return NULL;
memcpy(dest, orig, sz);
- return (dest);
+ return dest;
} /* }}} char *md_strdup */
static meta_entry_t *md_entry_alloc(const char *key) /* {{{ */
e = calloc(1, sizeof(*e));
if (e == NULL) {
ERROR("md_entry_alloc: calloc failed.");
- return (NULL);
+ return NULL;
}
e->key = md_strdup(key);
if (e->key == NULL) {
free(e);
ERROR("md_entry_alloc: md_strdup failed.");
- return (NULL);
+ return NULL;
}
e->type = 0;
e->next = NULL;
- return (e);
+ return e;
} /* }}} meta_entry_t *md_entry_alloc */
/* XXX: The lock on md must be held while calling this function! */
@@ -115,14 +115,14 @@ static meta_entry_t *md_entry_clone_contents(const meta_entry_t *orig) /* {{{ */
copy = md_entry_alloc(orig->key);
if (copy == NULL)
- return (NULL);
+ return NULL;
copy->type = orig->type;
if (copy->type == MD_TYPE_STRING)
copy->value.mv_string = strdup(orig->value.mv_string);
else
copy->value = orig->value;
- return (copy);
+ return copy;
} /* }}} meta_entry_t *md_entry_clone_contents */
static meta_entry_t *md_entry_clone(const meta_entry_t *orig) /* {{{ */
meta_entry_t *copy;
if (orig == NULL)
- return (NULL);
+ return NULL;
copy = md_entry_clone_contents(orig);
copy->next = md_entry_clone(orig->next);
- return (copy);
+ return copy;
} /* }}} meta_entry_t *md_entry_clone */
static void md_entry_free(meta_entry_t *e) /* {{{ */
meta_entry_t *prev;
if ((md == NULL) || (e == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
md_entry_free(this);
}
- return (0);
+ return 0;
} /* }}} int md_entry_insert */
/* XXX: The lock on md must be held while calling this function! */
md_entry_free(this);
}
- return (0);
+ return 0;
} /* }}} int md_entry_insert_clone */
/* XXX: The lock on md must be held while calling this function! */
meta_entry_t *e;
if ((md == NULL) || (key == NULL))
- return (NULL);
+ return NULL;
for (e = md->head; e != NULL; e = e->next)
if (strcasecmp(key, e->key) == 0)
break;
- return (e);
+ return e;
} /* }}} meta_entry_t *md_entry_lookup */
/*
md = calloc(1, sizeof(*md));
if (md == NULL) {
ERROR("meta_data_create: calloc failed.");
- return (NULL);
+ return NULL;
}
pthread_mutex_init(&md->lock, /* attr = */ NULL);
- return (md);
+ return md;
} /* }}} meta_data_t *meta_data_create */
meta_data_t *meta_data_clone(meta_data_t *orig) /* {{{ */
meta_data_t *copy;
if (orig == NULL)
- return (NULL);
+ return NULL;
copy = meta_data_create();
if (copy == NULL)
- return (NULL);
+ return NULL;
pthread_mutex_lock(&orig->lock);
copy->head = md_entry_clone(orig->head);
pthread_mutex_unlock(&orig->lock);
- return (copy);
+ return copy;
} /* }}} meta_data_t *meta_data_clone */
int meta_data_clone_merge(meta_data_t **dest, meta_data_t *orig) /* {{{ */
{
if (orig == NULL)
- return (0);
+ return 0;
if (*dest == NULL) {
*dest = meta_data_clone(orig);
- return (0);
+ return 0;
}
pthread_mutex_lock(&orig->lock);
}
pthread_mutex_unlock(&orig->lock);
- return (0);
+ return 0;
} /* }}} int meta_data_clone_merge */
void meta_data_destroy(meta_data_t *md) /* {{{ */
int meta_data_exists(meta_data_t *md, const char *key) /* {{{ */
{
if ((md == NULL) || (key == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
for (meta_entry_t *e = md->head; e != NULL; e = e->next) {
if (strcasecmp(key, e->key) == 0) {
pthread_mutex_unlock(&md->lock);
- return (1);
+ return 1;
}
}
pthread_mutex_unlock(&md->lock);
- return (0);
+ return 0;
} /* }}} int meta_data_exists */
int meta_data_type(meta_data_t *md, const char *key) /* {{{ */
if (count == 0) {
pthread_mutex_unlock(&md->lock);
- return (count);
+ return count;
}
*toc = calloc(count, sizeof(**toc));
meta_entry_t *prev;
if ((md == NULL) || (key == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
if (this == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (prev == NULL)
this->next = NULL;
md_entry_free(this);
- return (0);
+ return 0;
} /* }}} int meta_data_delete */
/*
meta_entry_t *e;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
e = md_entry_alloc(key);
if (e == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
e->value.mv_string = md_strdup(value);
if (e->value.mv_string == NULL) {
ERROR("meta_data_add_string: md_strdup failed.");
md_entry_free(e);
- return (-ENOMEM);
+ return -ENOMEM;
}
e->type = MD_TYPE_STRING;
- return (md_entry_insert(md, e));
+ return md_entry_insert(md, e);
} /* }}} int meta_data_add_string */
int meta_data_add_signed_int(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL))
- return (-EINVAL);
+ return -EINVAL;
e = md_entry_alloc(key);
if (e == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
e->value.mv_signed_int = value;
e->type = MD_TYPE_SIGNED_INT;
- return (md_entry_insert(md, e));
+ return md_entry_insert(md, e);
} /* }}} int meta_data_add_signed_int */
int meta_data_add_unsigned_int(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL))
- return (-EINVAL);
+ return -EINVAL;
e = md_entry_alloc(key);
if (e == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
e->value.mv_unsigned_int = value;
e->type = MD_TYPE_UNSIGNED_INT;
- return (md_entry_insert(md, e));
+ return md_entry_insert(md, e);
} /* }}} int meta_data_add_unsigned_int */
int meta_data_add_double(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL))
- return (-EINVAL);
+ return -EINVAL;
e = md_entry_alloc(key);
if (e == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
e->value.mv_double = value;
e->type = MD_TYPE_DOUBLE;
- return (md_entry_insert(md, e));
+ return md_entry_insert(md, e);
} /* }}} int meta_data_add_double */
int meta_data_add_boolean(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL))
- return (-EINVAL);
+ return -EINVAL;
e = md_entry_alloc(key);
if (e == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
e->value.mv_boolean = value;
e->type = MD_TYPE_BOOLEAN;
- return (md_entry_insert(md, e));
+ return md_entry_insert(md, e);
} /* }}} int meta_data_add_boolean */
/*
char *temp;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
e = md_entry_lookup(md, key);
if (e == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (e->type != MD_TYPE_STRING) {
ERROR("meta_data_get_string: Type mismatch for key `%s'", e->key);
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
temp = md_strdup(e->value.mv_string);
if (temp == NULL) {
pthread_mutex_unlock(&md->lock);
ERROR("meta_data_get_string: md_strdup failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
pthread_mutex_unlock(&md->lock);
*value = temp;
- return (0);
+ return 0;
} /* }}} int meta_data_get_string */
int meta_data_get_signed_int(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
e = md_entry_lookup(md, key);
if (e == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (e->type != MD_TYPE_SIGNED_INT) {
ERROR("meta_data_get_signed_int: Type mismatch for key `%s'", e->key);
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
*value = e->value.mv_signed_int;
pthread_mutex_unlock(&md->lock);
- return (0);
+ return 0;
} /* }}} int meta_data_get_signed_int */
int meta_data_get_unsigned_int(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
e = md_entry_lookup(md, key);
if (e == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (e->type != MD_TYPE_UNSIGNED_INT) {
ERROR("meta_data_get_unsigned_int: Type mismatch for key `%s'", e->key);
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
*value = e->value.mv_unsigned_int;
pthread_mutex_unlock(&md->lock);
- return (0);
+ return 0;
} /* }}} int meta_data_get_unsigned_int */
int meta_data_get_double(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
e = md_entry_lookup(md, key);
if (e == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (e->type != MD_TYPE_DOUBLE) {
ERROR("meta_data_get_double: Type mismatch for key `%s'", e->key);
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
*value = e->value.mv_double;
pthread_mutex_unlock(&md->lock);
- return (0);
+ return 0;
} /* }}} int meta_data_get_double */
int meta_data_get_boolean(meta_data_t *md, /* {{{ */
meta_entry_t *e;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
e = md_entry_lookup(md, key);
if (e == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (e->type != MD_TYPE_BOOLEAN) {
ERROR("meta_data_get_boolean: Type mismatch for key `%s'", e->key);
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
*value = e->value.mv_boolean;
pthread_mutex_unlock(&md->lock);
- return (0);
+ return 0;
} /* }}} int meta_data_get_boolean */
int meta_data_as_string(meta_data_t *md, /* {{{ */
int type;
if ((md == NULL) || (key == NULL) || (value == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&md->lock);
e = md_entry_lookup(md, key);
if (e == NULL) {
pthread_mutex_unlock(&md->lock);
- return (-ENOENT);
+ return -ENOENT;
}
type = e->type;
default:
pthread_mutex_unlock(&md->lock);
ERROR("meta_data_as_string: unknown type %d for key `%s'", type, key);
- return (-ENOENT);
+ return -ENOENT;
}
pthread_mutex_unlock(&md->lock);
if (temp == NULL) {
pthread_mutex_unlock(&md->lock);
ERROR("meta_data_as_string: md_strdup failed for key `%s'.", key);
- return (-ENOMEM);
+ return -ENOMEM;
}
*value = temp;
- return (0);
+ return 0;
} /* }}} int meta_data_as_string */
diff --git a/src/daemon/plugin.c b/src/daemon/plugin.c
index b37e9b325c32e9492e92a3e29caa49a5e78d34e4..3bf183d9c066934ecbfd664ef1c25e75d1c1920c 100644 (file)
--- a/src/daemon/plugin.c
+++ b/src/daemon/plugin.c
static const char *plugin_get_dir(void) {
if (plugindir == NULL)
- return (PLUGINDIR);
+ return PLUGINDIR;
else
- return (plugindir);
+ return plugindir;
}
static int plugin_update_internal_statistics(void) { /* {{{ */
ERROR("plugin: register_callback: "
"llist_create failed.");
destroy_callback(cf);
- return (-1);
+ return -1;
}
}
if (key == NULL) {
ERROR("plugin: register_callback: strdup failed.");
destroy_callback(cf);
- return (-1);
+ return -1;
}
le = llist_search(*list, name);
"llentry_create failed.");
sfree(key);
destroy_callback(cf);
- return (-1);
+ return -1;
}
llist_append(*list, le);
sfree(key);
}
- return (0);
+ return 0;
} /* }}} int register_callback */
static void log_list_callbacks(llist_t **list, /* {{{ */
cf = calloc(1, sizeof(*cf));
if (cf == NULL) {
ERROR("plugin: create_register_callback: calloc failed.");
- return (-1);
+ return -1;
}
cf->cf_callback = callback;
cf->cf_ctx = plugin_get_ctx();
- return (register_callback(list, name, cf));
+ return register_callback(list, name, cf);
} /* }}} int create_register_callback */
static int plugin_unregister(llist_t *list, const char *name) /* {{{ */
llentry_t *e;
if (list == NULL)
- return (-1);
+ return -1;
e = llist_search(list, name);
if (e == NULL)
- return (-1);
+ return -1;
llist_remove(list, e);
llentry_destroy(e);
- return (0);
+ return 0;
} /* }}} int plugin_unregister */
/*
if (list_log != NULL)
fprintf(stderr, "ERROR: %s\n", errbuf);
- return (1);
+ return 1;
}
reg_handle = (void (*)(void))dlsym(dlh, "module_register");
WARNING("Couldn't find symbol \"module_register\" in \"%s\": %s\n", file,
dlerror());
dlclose(dlh);
- return (-1);
+ return -1;
}
(*reg_handle)();
- return (0);
+ return 0;
}
static void *plugin_read_thread(void __attribute__((unused)) * args) {
} /* while (read_loop) */
pthread_exit(NULL);
- return ((void *)0);
+ return (void *)0;
} /* void *plugin_read_thread */
#ifdef PTHREAD_MAX_NAMELEN_NP
value_list_t *vl;
if (vl_orig == NULL)
- return (NULL);
+ return NULL;
vl = malloc(sizeof(*vl));
if (vl == NULL)
- return (NULL);
+ return NULL;
memcpy(vl, vl_orig, sizeof(*vl));
if (vl->host[0] == 0)
vl->values = calloc(vl_orig->values_len, sizeof(*vl->values));
if (vl->values == NULL) {
plugin_value_list_free(vl);
- return (NULL);
+ return NULL;
}
memcpy(vl->values, vl_orig->values,
vl_orig->values_len * sizeof(*vl->values));
vl->meta = meta_data_clone(vl->meta);
if ((vl_orig->meta != NULL) && (vl->meta == NULL)) {
plugin_value_list_free(vl);
- return (NULL);
+ return NULL;
}
if (vl->time == 0)
}
}
- return (vl);
+ return vl;
} /* }}} value_list_t *plugin_value_list_clone */
static int plugin_write_enqueue(value_list_t const *vl) /* {{{ */
q = malloc(sizeof(*q));
if (q == NULL)
- return (ENOMEM);
+ return ENOMEM;
q->next = NULL;
q->vl = plugin_value_list_clone(vl);
if (q->vl == NULL) {
sfree(q);
- return (ENOMEM);
+ return ENOMEM;
}
/* Store context of caller (read plugin); otherwise, it would not be
pthread_cond_signal(&write_cond);
pthread_mutex_unlock(&write_lock);
- return (0);
+ return 0;
} /* }}} int plugin_write_enqueue */
static value_list_t *plugin_write_dequeue(void) /* {{{ */
if (write_queue_head == NULL) {
pthread_mutex_unlock(&write_lock);
- return (NULL);
+ return NULL;
}
q = write_queue_head;
vl = q->vl;
sfree(q);
- return (vl);
+ return vl;
} /* }}} value_list_t *plugin_write_dequeue */
static void *plugin_write_thread(void __attribute__((unused)) * args) /* {{{ */
}
pthread_exit(NULL);
- return ((void *)0);
+ return (void *)0;
} /* }}} void *plugin_write_thread */
static void start_write_threads(size_t num) /* {{{ */
assert(plugins_loaded != NULL);
status = c_avl_get(plugins_loaded, name, /* ret_value = */ NULL);
- return (status == 0);
+ return status == 0;
}
static int plugin_mark_loaded(char const *name) {
name_copy = strdup(name);
if (name_copy == NULL)
- return (ENOMEM);
+ return ENOMEM;
status = c_avl_insert(plugins_loaded,
/* key = */ name_copy, /* value = */ NULL);
- return (status);
+ return status;
}
static void plugin_free_loaded(void) {
int status;
if (plugin_name == NULL)
- return (EINVAL);
+ return EINVAL;
/* Check if plugin is already loaded and don't do anything in this
* case. */
if (plugin_is_loaded(plugin_name))
- return (0);
+ return 0;
dir = plugin_get_dir();
ret = 1;
status = ssnprintf(typename, sizeof(typename), "%s.so", plugin_name);
if ((status < 0) || ((size_t)status >= sizeof(typename))) {
WARNING("plugin_load: Filename too long: \"%s.so\"", plugin_name);
- return (-1);
+ return -1;
}
if ((dh = opendir(dir)) == NULL) {
char errbuf[1024];
ERROR("plugin_load: opendir (%s) failed: %s", dir,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while ((de = readdir(dh)) != NULL) {
if (filename[0] == 0)
ERROR("plugin_load: Could not find plugin \"%s\" in %s", plugin_name, dir);
- return (ret);
+ return ret;
}
/*
int (*callback)(const char *key, const char *val),
const char **keys, int keys_num) {
cf_register(name, callback, keys, keys_num);
- return (0);
+ return 0;
} /* int plugin_register_config */
int plugin_register_complex_config(const char *type,
int (*callback)(oconfig_item_t *)) {
- return (cf_register_complex(type, callback));
+ return cf_register_complex(type, callback);
} /* int plugin_register_complex_config */
int plugin_register_init(const char *name, int (*callback)(void)) {
- return (create_register_callback(&list_init, name, (void *)callback,
- /* user_data = */ NULL));
+ return create_register_callback(&list_init, name, (void *)callback, NULL);
} /* plugin_register_init */
static int plugin_compare_read_func(const void *arg0, const void *arg1) {
rf1 = arg1;
if (rf0->rf_next_read < rf1->rf_next_read)
- return (-1);
+ return -1;
else if (rf0->rf_next_read > rf1->rf_next_read)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* int plugin_compare_read_func */
/* Add a read function to both, the heap and a linked list. The linked list if
if (read_list == NULL) {
pthread_mutex_unlock(&read_lock);
ERROR("plugin_insert_read: read_list failed.");
- return (-1);
+ return -1;
}
}
if (read_heap == NULL) {
pthread_mutex_unlock(&read_lock);
ERROR("plugin_insert_read: c_heap_create failed.");
- return (-1);
+ return -1;
}
}
"Check for duplicate \"LoadPlugin\" lines "
"in your configuration!",
rf->rf_name);
- return (EINVAL);
+ return EINVAL;
}
le = llentry_create(rf->rf_name, rf);
if (le == NULL) {
pthread_mutex_unlock(&read_lock);
ERROR("plugin_insert_read: llentry_create failed.");
- return (-1);
+ return -1;
}
status = c_heap_insert(read_heap, rf);
pthread_mutex_unlock(&read_lock);
ERROR("plugin_insert_read: c_heap_insert failed.");
llentry_destroy(le);
- return (-1);
+ return -1;
}
/* This does not fail. */
/* Wake up all the read threads. */
pthread_cond_broadcast(&read_cond);
pthread_mutex_unlock(&read_lock);
- return (0);
+ return 0;
} /* int plugin_insert_read */
int plugin_register_read(const char *name, int (*callback)(void)) {
rf = calloc(1, sizeof(*rf));
if (rf == NULL) {
ERROR("plugin_register_read: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
rf->rf_callback = (void *)callback;
sfree(rf);
}
- return (status);
+ return status;
} /* int plugin_register_read */
int plugin_register_complex_read(const char *group, const char *name,
rf = calloc(1, sizeof(*rf));
if (rf == NULL) {
ERROR("plugin_register_complex_read: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
rf->rf_callback = (void *)callback;
sfree(rf);
}
- return (status);
+ return status;
} /* int plugin_register_complex_read */
int plugin_register_write(const char *name, plugin_write_cb callback,
user_data_t const *ud) {
- return (create_register_callback(&list_write, name, (void *)callback, ud));
+ return create_register_callback(&list_write, name, (void *)callback, ud);
} /* int plugin_register_write */
static int plugin_flush_timeout_callback(user_data_t *ud) {
flush_callback_t *cb = ud->data;
- return plugin_flush(cb->name, cb->timeout, /* identifier = */ NULL);
+ return plugin_flush(cb->name, cb->timeout, NULL);
} /* static int plugin_flush_callback */
static void plugin_flush_timeout_callback_free(void *data) {
flush_name = malloc(name_size + prefix_size + 1);
if (flush_name == NULL) {
ERROR("plugin_flush_callback_name: malloc failed.");
- return (NULL);
+ return NULL;
}
sstrncpy(flush_name, flush_prefix, prefix_size + 1);
flush_name = plugin_flush_callback_name(name);
if (flush_name == NULL)
- return (-1);
+ return -1;
cb = malloc(sizeof(*cb));
if (cb == NULL) {
ERROR("plugin_register_flush: malloc failed.");
sfree(flush_name);
- return (-1);
+ return -1;
}
cb->name = strdup(name);
ERROR("plugin_register_flush: strdup failed.");
sfree(cb);
sfree(flush_name);
- return (-1);
+ return -1;
}
cb->timeout = ctx.flush_timeout;
int plugin_register_missing(const char *name, plugin_missing_cb callback,
user_data_t const *ud) {
- return (create_register_callback(&list_missing, name, (void *)callback, ud));
+ return create_register_callback(&list_missing, name, (void *)callback, ud);
} /* int plugin_register_missing */
int plugin_register_shutdown(const char *name, int (*callback)(void)) {
- return (create_register_callback(&list_shutdown, name, (void *)callback,
- /* user_data = */ NULL));
+ return create_register_callback(&list_shutdown, name, (void *)callback,
+ NULL);
} /* int plugin_register_shutdown */
static void plugin_free_data_sets(void) {
} else if (data_sets == NULL) {
data_sets = c_avl_create((int (*)(const void *, const void *))strcmp);
if (data_sets == NULL)
- return (-1);
+ return -1;
}
ds_copy = malloc(sizeof(*ds_copy));
if (ds_copy == NULL)
- return (-1);
+ return -1;
memcpy(ds_copy, ds, sizeof(data_set_t));
ds_copy->ds = malloc(sizeof(*ds_copy->ds) * ds->ds_num);
if (ds_copy->ds == NULL) {
sfree(ds_copy);
- return (-1);
+ return -1;
}
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));
+ return c_avl_insert(data_sets, (void *)ds_copy->type, (void *)ds_copy);
} /* int plugin_register_data_set */
int plugin_register_log(const char *name, plugin_log_cb callback,
user_data_t const *ud) {
- return (create_register_callback(&list_log, name, (void *)callback, ud));
+ return create_register_callback(&list_log, name, (void *)callback, ud);
} /* int plugin_register_log */
int plugin_register_notification(const char *name,
plugin_notification_cb callback,
user_data_t const *ud) {
- return (
- create_register_callback(&list_notification, name, (void *)callback, ud));
+ return create_register_callback(&list_notification, name, (void *)callback,
+ ud);
} /* int plugin_register_log */
int plugin_unregister_config(const char *name) {
cf_unregister(name);
- return (0);
+ return 0;
} /* int plugin_unregister_config */
int plugin_unregister_complex_config(const char *name) {
cf_unregister_complex(name);
- return (0);
+ return 0;
} /* int plugin_unregister_complex_config */
int plugin_unregister_init(const char *name) {
- return (plugin_unregister(list_init, name));
+ return plugin_unregister(list_init, name);
}
int plugin_unregister_read(const char *name) /* {{{ */
read_func_t *rf;
if (name == NULL)
- return (-ENOENT);
+ return -ENOENT;
pthread_mutex_lock(&read_lock);
if (read_list == NULL) {
pthread_mutex_unlock(&read_lock);
- return (-ENOENT);
+ return -ENOENT;
}
le = llist_search(read_list, name);
if (le == NULL) {
pthread_mutex_unlock(&read_lock);
WARNING("plugin_unregister_read: No such read function: %s", name);
- return (-ENOENT);
+ return -ENOENT;
}
llist_remove(read_list, le);
DEBUG("plugin_unregister_read: Marked `%s' for removal.", name);
- return (0);
+ return 0;
} /* }}} int plugin_unregister_read */
void plugin_log_available_writers(void) {
int found = 0;
if (group == NULL)
- return (-ENOENT);
+ return -ENOENT;
pthread_mutex_lock(&read_lock);
if (read_list == NULL) {
pthread_mutex_unlock(&read_lock);
- return (-ENOENT);
+ return -ENOENT;
}
while (42) {
WARNING("plugin_unregister_read_group: No such "
"group of read function: %s",
group);
- return (-ENOENT);
+ return -ENOENT;
}
- return (0);
+ return 0;
} /* }}} int plugin_unregister_read_group */
int plugin_unregister_write(const char *name) {
- return (plugin_unregister(list_write, name));
+ return plugin_unregister(list_write, name);
}
int plugin_unregister_flush(const char *name) {
}
int plugin_unregister_missing(const char *name) {
- return (plugin_unregister(list_missing, name));
+ return plugin_unregister(list_missing, name);
}
int plugin_unregister_shutdown(const char *name) {
- return (plugin_unregister(list_shutdown, name));
+ return plugin_unregister(list_shutdown, name);
}
int plugin_unregister_data_set(const char *name) {
data_set_t *ds;
if (data_sets == NULL)
- return (-1);
+ return -1;
if (c_avl_remove(data_sets, name, NULL, (void *)&ds) != 0)
- return (-1);
+ return -1;
sfree(ds->ds);
sfree(ds);
- return (0);
+ return 0;
} /* int plugin_unregister_data_set */
int plugin_unregister_log(const char *name) {
- return (plugin_unregister(list_log, name));
+ return plugin_unregister(list_log, name);
}
int plugin_unregister_notification(const char *name) {
- return (plugin_unregister(list_notification, name));
+ return plugin_unregister(list_notification, name);
}
int plugin_init_all(void) {
if (read_heap == NULL) {
NOTICE("No read-functions are registered.");
- return (0);
+ return 0;
}
while (42) {
destroy_callback((void *)rf);
}
- return (return_status);
+ return return_status;
} /* int plugin_read_all_once */
int plugin_write(const char *plugin, /* {{{ */
int status;
if (vl == NULL)
- return (EINVAL);
+ return EINVAL;
if (list_write == NULL)
- return (ENOENT);
+ return ENOENT;
if (ds == NULL) {
ds = plugin_get_ds(vl->type);
if (ds == NULL) {
ERROR("plugin_write: Unable to lookup type `%s'.", vl->type);
- return (ENOENT);
+ return ENOENT;
}
}
}
if (le == NULL)
- return (ENOENT);
+ return ENOENT;
cf = le->value;
status = (*callback)(ds, vl, &cf->cf_udata);
}
- return (status);
+ return status;
} /* }}} int plugin_write */
int plugin_flush(const char *plugin, cdtime_t timeout, const char *identifier) {
llentry_t *le;
if (list_flush == NULL)
- return (0);
+ return 0;
le = llist_head(list_flush);
while (le != NULL) {
@@ -1801,7 +1800,7 @@ int plugin_flush(const char *plugin, cdtime_t timeout, const char *identifier) {
le = le->next;
}
- return (0);
+ return 0;
} /* int plugin_flush */
int plugin_shutdown_all(void) {
plugin_free_loaded();
plugin_free_data_sets();
- return (ret);
+ return ret;
} /* void plugin_shutdown_all */
int plugin_dispatch_missing(const value_list_t *vl) /* {{{ */
llentry_t *le;
if (list_missing == NULL)
- return (0);
+ return 0;
le = llist_head(list_missing);
while (le != NULL) {
ERROR("plugin_dispatch_missing: Callback function \"%s\" "
"failed with status %i.",
le->key, status);
- return (status);
+ return status;
} else {
- return (0);
+ return 0;
}
}
le = le->next;
}
- return (0);
+ return 0;
} /* int }}} plugin_dispatch_missing */
static int plugin_dispatch_values_internal(value_list_t *vl) {
ERROR("plugin_dispatch_values: Invalid value list "
"from plugin %s.",
vl->plugin);
- return (-1);
+ return -1;
}
/* Free meta data only if the calling function didn't specify any. In
ERROR("plugin_dispatch_values: No data sets registered. "
"Could the types database be read? Check "
"your `TypesDB' setting!");
- return (-1);
+ return -1;
}
if (c_avl_get(data_sets, vl->type, (void *)&ds) != 0) {
INFO("plugin_dispatch_values: Dataset not found: %s "
"(from \"%s\"), check your types.db!",
vl->type, ident);
- return (-1);
+ return -1;
}
DEBUG("plugin_dispatch_values: time = %.3f; interval = %.3f; "
"(ds->ds_num = %zu) != "
"(vl->values_len = %zu)",
ds->type, ds->ds_num, vl->values_len);
- return (-1);
+ return -1;
}
#endif
"status %i (%#x).",
status, status);
} else if (status == FC_TARGET_STOP)
- return (0);
+ return 0;
}
/* Update the value cache */
vl->meta = NULL;
}
- return (0);
+ return 0;
} /* int plugin_dispatch_values_internal */
static double get_drop_probability(void) /* {{{ */
pthread_mutex_unlock(&write_lock);
if (wql < write_limit_low)
- return (0.0);
+ return 0.0;
if (wql >= write_limit_high)
- return (1.0);
+ return 1.0;
pos = 1 + wql - write_limit_low;
size = 1 + write_limit_high - write_limit_low;
- return (((double)pos) / ((double)size));
+ return (double)pos / (double)size;
} /* }}} double get_drop_probability */
static _Bool check_drop_value(void) /* {{{ */
int status;
if (write_limit_high == 0)
- return (0);
+ return 0;
p = get_drop_probability();
if (p == 0.0)
- return (0);
+ return 0;
status = pthread_mutex_trylock(&last_message_lock);
if (status == 0) {
}
if (p == 1.0)
- return (1);
+ return 1;
q = cdrand_d();
if (q > p)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* }}} _Bool check_drop_value */
int plugin_dispatch_values(value_list_t const *vl) {
stats_values_dropped++;
pthread_mutex_unlock(&statistics_lock);
}
- return (0);
+ return 0;
}
status = plugin_write_enqueue(vl);
ERROR("plugin_dispatch_values: plugin_write_enqueue failed "
"with status %i (%s).",
status, sstrerror(status, errbuf, sizeof(errbuf)));
- return (status);
+ return status;
}
- return (0);
+ return 0;
}
__attribute__((sentinel)) int
va_end(ap);
plugin_value_list_free(vl);
- return (failed);
+ return failed;
} /* }}} int plugin_dispatch_multivalue */
int plugin_dispatch_notification(const notification_t *notif) {
/* Nobody cares for notifications */
if (list_notification == NULL)
- return (-1);
+ return -1;
le = llist_head(list_notification);
while (le != NULL) {
le = le->next;
}
- return (0);
+ return 0;
} /* int plugin_dispatch_notification */
void plugin_log(int level, const char *format, ...) {
log_level = LOG_DEBUG;
#endif /* COLLECT_DEBUG */
- return (log_level);
+ return log_level;
} /* int parse_log_severity */
int parse_notif_severity(const char *severity) {
(strcmp(severity, "WARN") == 0))
notif_severity = NOTIF_WARNING;
- return (notif_severity);
+ return notif_severity;
} /* int parse_notif_severity */
const data_set_t *plugin_get_ds(const char *name) {
if (data_sets == NULL) {
ERROR("plugin_get_ds: No data sets are defined yet.");
- return (NULL);
+ return NULL;
}
if (c_avl_get(data_sets, name, (void *)&ds) != 0) {
DEBUG("No such dataset registered: %s", name);
- return (NULL);
+ return NULL;
}
- return (ds);
+ return ds;
} /* data_set_t *plugin_get_ds */
static int plugin_notification_meta_add(notification_t *n, const char *name,
@@ -2317,13 +2316,13 @@ static int plugin_notification_meta_add(notification_t *n, const char *name,
if ((n == NULL) || (name == NULL) || (value == NULL)) {
ERROR("plugin_notification_meta_add: A pointer is NULL!");
- return (-1);
+ return -1;
}
meta = calloc(1, sizeof(*meta));
if (meta == NULL) {
ERROR("plugin_notification_meta_add: calloc failed.");
- return (-1);
+ return -1;
}
sstrncpy(meta->name, name, sizeof(meta->name));
if (meta->nm_value.nm_string == NULL) {
ERROR("plugin_notification_meta_add: strdup failed.");
sfree(meta);
- return (-1);
+ return -1;
}
break;
}
default: {
ERROR("plugin_notification_meta_add: Unknown type: %i", type);
sfree(meta);
- return (-1);
+ return -1;
}
} /* switch (type) */
@@ -2372,33 +2371,33 @@ static int plugin_notification_meta_add(notification_t *n, const char *name,
else
tail->next = meta;
- return (0);
+ return 0;
} /* int plugin_notification_meta_add */
int plugin_notification_meta_add_string(notification_t *n, const char *name,
const char *value) {
- return (plugin_notification_meta_add(n, name, NM_TYPE_STRING, value));
+ return plugin_notification_meta_add(n, name, NM_TYPE_STRING, value);
}
int plugin_notification_meta_add_signed_int(notification_t *n, const char *name,
int64_t value) {
- return (plugin_notification_meta_add(n, name, NM_TYPE_SIGNED_INT, &value));
+ return plugin_notification_meta_add(n, name, NM_TYPE_SIGNED_INT, &value);
}
int plugin_notification_meta_add_unsigned_int(notification_t *n,
const char *name,
uint64_t value) {
- return (plugin_notification_meta_add(n, name, NM_TYPE_UNSIGNED_INT, &value));
+ return plugin_notification_meta_add(n, name, NM_TYPE_UNSIGNED_INT, &value);
}
int plugin_notification_meta_add_double(notification_t *n, const char *name,
double value) {
- return (plugin_notification_meta_add(n, name, NM_TYPE_DOUBLE, &value));
+ return plugin_notification_meta_add(n, name, NM_TYPE_DOUBLE, &value);
}
int plugin_notification_meta_add_boolean(notification_t *n, const char *name,
_Bool value) {
- return (plugin_notification_meta_add(n, name, NM_TYPE_BOOLEAN, &value));
+ return plugin_notification_meta_add(n, name, NM_TYPE_BOOLEAN, &value);
}
int plugin_notification_meta_copy(notification_t *dst,
meta->nm_value.nm_boolean);
}
- return (0);
+ return 0;
} /* int plugin_notification_meta_copy */
int plugin_notification_meta_free(notification_meta_t *n) {
if (n == NULL) {
ERROR("plugin_notification_meta_free: n == NULL!");
- return (-1);
+ return -1;
}
this = n;
this = next;
}
- return (0);
+ return 0;
} /* int plugin_notification_meta_free */
static void plugin_ctx_destructor(void *ctx) {
assert(plugin_ctx_key_initialized);
pthread_setspecific(plugin_ctx_key, ctx);
DEBUG("Created new plugin context.");
- return (ctx);
+ return ctx;
} /* int plugin_ctx_create */
void plugin_init_ctx(void) {
return ctx_init;
}
- return (*ctx);
+ return *ctx;
} /* plugin_ctx_t plugin_get_ctx */
plugin_ctx_t plugin_set_ctx(plugin_ctx_t ctx) {
old = *c;
*c = ctx;
- return (old);
+ return old;
} /* void plugin_set_ctx */
cdtime_t plugin_get_interval(void) {
index b053157154cf74d18e012ed45152ddf73759233b..89a08dd7f30ff61a45abe650fd2a7c2575654983 100644 (file)
--- a/src/daemon/types_list.c
+++ b/src/daemon/types_list.c
if (buf_len < 11) {
ERROR("parse_ds: (buf_len = %zu) < 11", buf_len);
- return (-1);
+ return -1;
}
if (buf[buf_len - 1] == ',') {
if (fields_num != 4) {
ERROR("parse_ds: (fields_num = %i) != 4", fields_num);
- return (-1);
+ return -1;
}
sstrncpy(dsrc->name, fields[0], sizeof(dsrc->name));
else {
ERROR("(fields[1] = %s) != (GAUGE || COUNTER || DERIVE || ABSOLUTE)",
fields[1]);
- return (-1);
+ return -1;
}
if (strcasecmp(fields[2], "U") == 0)
else
dsrc->max = atof(fields[3]);
- return (0);
+ return 0;
} /* int parse_ds */
static void parse_line(char *buf) {
FILE *fh;
if (file == NULL)
- return (-1);
+ return -1;
fh = fopen(file, "r");
if (fh == NULL) {
sstrerror(errno, errbuf, sizeof(errbuf)));
ERROR("Failed to open types database `%s': %s", file,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
parse_file(fh);
DEBUG("Done parsing `%s'", file);
- return (0);
+ return 0;
} /* int read_types_list */
index 92259ae19d5ada9c0ea756e548ea59a6e0525c7d..6a4e0f3e4dd8b523893f6a0ca80d682bed633df3 100644 (file)
int height_right;
if (n == NULL)
- return (0);
+ return 0;
height_left = (n->left == NULL) ? 0 : n->left->height;
height_right = (n->right == NULL) ? 0 : n->right->height;
- return (((height_left > height_right) ? height_left : height_right) + 1);
+ return ((height_left > height_right) ? height_left : height_right) + 1;
} /* int calc_height */
static c_avl_node_t *search(c_avl_tree_t *t, const void *key) {
while (n != NULL) {
cmp = t->compare(key, n->key);
if (cmp == 0)
- return (n);
+ return n;
else if (cmp < 0)
n = n->left;
else
n = n->right;
}
- return (NULL);
+ return NULL;
}
/* (x) (y)
x->height = calc_height(x);
y->height = calc_height(y);
- return (y);
+ return y;
} /* void rotate_right */
/*
x->height = calc_height(x);
y->height = calc_height(y);
- return (y);
+ return y;
} /* void rotate_left */
static c_avl_node_t *rotate_left_right(c_avl_tree_t *t, c_avl_node_t *x) {
rotate_left(t, x->left);
- return (rotate_right(t, x));
+ return rotate_right(t, x);
} /* void rotate_left_right */
static c_avl_node_t *rotate_right_left(c_avl_tree_t *t, c_avl_node_t *x) {
rotate_right(t, x->right);
- return (rotate_left(t, x));
+ return rotate_left(t, x);
} /* void rotate_right_left */
static void rebalance(c_avl_tree_t *t, c_avl_node_t *n) {
c_avl_node_t *r; /* return node */
if (n == NULL) {
- return (NULL);
+ return NULL;
}
/* If we can't descent any further, we have to backtrack to the first
* r->left != n => r->right = n => r->parent == NULL */
if ((r == NULL) || (r->left != n)) {
assert((r == NULL) || (r->parent == NULL));
- return (NULL);
+ return NULL;
} else {
assert(r->left == n);
- return (r);
+ return r;
}
} else {
r = n->right;
r = r->left;
}
- return (r);
+ return r;
} /* c_avl_node_t *c_avl_node_next */
static c_avl_node_t *c_avl_node_prev(c_avl_node_t *n) {
c_avl_node_t *r; /* return node */
if (n == NULL) {
- return (NULL);
+ return NULL;
}
/* If we can't descent any further, we have to backtrack to the first
* r->right != n => r->left = n => r->parent == NULL */
if ((r == NULL) || (r->right != n)) {
assert((r == NULL) || (r->parent == NULL));
- return (NULL);
+ return NULL;
} else {
assert(r->right == n);
- return (r);
+ return r;
}
} else {
r = n->left;
r = r->right;
}
- return (r);
+ return r;
} /* c_avl_node_t *c_avl_node_prev */
static int _remove(c_avl_tree_t *t, c_avl_node_t *n) {
assert(0);
}
- return (0);
+ return 0;
} /* void *_remove */
/*
c_avl_tree_t *t;
if (compare == NULL)
- return (NULL);
+ return NULL;
if ((t = malloc(sizeof(*t))) == NULL)
- return (NULL);
+ return NULL;
t->root = NULL;
t->compare = compare;
t->size = 0;
- return (t);
+ return t;
}
void c_avl_destroy(c_avl_tree_t *t) {
int cmp;
if ((new = malloc(sizeof(*new))) == NULL)
- return (-1);
+ return -1;
new->key = key;
new->value = value;
new->parent = NULL;
t->root = new;
t->size = 1;
- return (0);
+ return 0;
}
nptr = t->root;
cmp = t->compare(nptr->key, new->key);
if (cmp == 0) {
free_node(new);
- return (1);
+ return 1;
} else if (cmp < 0) {
/* nptr < new */
if (nptr->right == NULL) {
verify_tree(t->root);
++t->size;
- return (0);
+ return 0;
} /* int c_avl_insert */
int c_avl_remove(c_avl_tree_t *t, const void *key, void **rkey, void **rvalue) {
@@ -502,7 +502,7 @@ int c_avl_remove(c_avl_tree_t *t, const void *key, void **rkey, void **rvalue) {
n = search(t, key);
if (n == NULL)
- return (-1);
+ return -1;
if (rkey != NULL)
*rkey = n->key;
@@ -512,7 +512,7 @@ int c_avl_remove(c_avl_tree_t *t, const void *key, void **rkey, void **rvalue) {
status = _remove(t, n);
verify_tree(t->root);
--t->size;
- return (status);
+ return status;
} /* void *c_avl_remove */
int c_avl_get(c_avl_tree_t *t, const void *key, void **value) {
n = search(t, key);
if (n == NULL)
- return (-1);
+ return -1;
if (value != NULL)
*value = n->value;
- return (0);
+ return 0;
}
int c_avl_pick(c_avl_tree_t *t, void **key, void **value) {
c_avl_node_t *p;
if ((key == NULL) || (value == NULL))
- return (-1);
+ return -1;
if (t->root == NULL)
- return (-1);
+ return -1;
n = t->root;
while ((n->left != NULL) || (n->right != NULL)) {
--t->size;
rebalance(t, p);
- return (0);
+ return 0;
} /* int c_avl_pick */
c_avl_iterator_t *c_avl_get_iterator(c_avl_tree_t *t) {
c_avl_iterator_t *iter;
if (t == NULL)
- return (NULL);
+ return NULL;
iter = calloc(1, sizeof(*iter));
if (iter == NULL)
- return (NULL);
+ return NULL;
iter->tree = t;
- return (iter);
+ return iter;
} /* c_avl_iterator_t *c_avl_get_iterator */
int c_avl_iterator_next(c_avl_iterator_t *iter, void **key, void **value) {
c_avl_node_t *n;
if ((iter == NULL) || (key == NULL) || (value == NULL))
- return (-1);
+ return -1;
if (iter->node == NULL) {
for (n = iter->tree->root; n != NULL; n = n->left)
}
if (n == NULL)
- return (-1);
+ return -1;
iter->node = n;
*key = n->key;
*value = n->value;
- return (0);
+ return 0;
} /* int c_avl_iterator_next */
int c_avl_iterator_prev(c_avl_iterator_t *iter, void **key, void **value) {
c_avl_node_t *n;
if ((iter == NULL) || (key == NULL) || (value == NULL))
- return (-1);
+ return -1;
if (iter->node == NULL) {
for (n = iter->tree->root; n != NULL; n = n->left)
}
if (n == NULL)
- return (-1);
+ return -1;
iter->node = n;
*key = n->key;
*value = n->value;
- return (0);
+ return 0;
} /* int c_avl_iterator_prev */
void c_avl_iterator_destroy(c_avl_iterator_t *iter) { free(iter); }
int c_avl_size(c_avl_tree_t *t) {
if (t == NULL)
- return (0);
- return (t->size);
+ return 0;
+ return t->size;
}
index 345f97bf4c3cb8efd51fd9be91d287996344455c..bb30f9d6fe23a36e829bf07d00eceb9fce042f8c 100644 (file)
assert(v1 != NULL);
compare_total_count++;
- return (strcmp(v0, v1));
+ return strcmp(v0, v1);
}
DEF_TEST(success) {
c_avl_destroy(t);
- return (0);
+ return 0;
}
int main(void) {
index 0caf22c550304fa49bd20f95548d418c35da825b..5e111e6d06342792f1d90583c030099fca42005c 100644 (file)
--- a/src/daemon/utils_cache.c
+++ b/src/daemon/utils_cache.c
#if COLLECT_DEBUG
assert((a != NULL) && (b != NULL));
#endif
- return (strcmp(a->name, b->name));
+ return strcmp(a->name, b->name);
} /* int cache_compare */
static cache_entry_t *cache_alloc(size_t values_num) {
ce = calloc(1, sizeof(*ce));
if (ce == NULL) {
ERROR("utils_cache: cache_alloc: calloc failed.");
- return (NULL);
+ return NULL;
}
ce->values_num = values_num;
sfree(ce->values_raw);
sfree(ce);
ERROR("utils_cache: cache_alloc: calloc failed.");
- return (NULL);
+ return NULL;
}
ce->history = NULL;
ce->history_length = 0;
ce->meta = NULL;
- return (ce);
+ return ce;
} /* cache_entry_t *cache_alloc */
static void cache_free(cache_entry_t *ce) {
key_copy = strdup(key);
if (key_copy == NULL) {
ERROR("uc_insert: strdup failed.");
- return (-1);
+ return -1;
}
ce = cache_alloc(ds->ds_num);
if (ce == NULL) {
sfree(key_copy);
ERROR("uc_insert: cache_alloc (%zu) failed.", ds->ds_num);
- return (-1);
+ return -1;
}
sstrncpy(ce->name, key, sizeof(ce->name));
ds->ds[i].type);
sfree(key_copy);
cache_free(ce);
- return (-1);
+ return -1;
} /* switch (ds->ds[i].type) */
} /* for (i) */
if (c_avl_insert(cache_tree, key_copy, ce) != 0) {
sfree(key_copy);
ERROR("uc_insert: c_avl_insert failed.");
- return (-1);
+ return -1;
}
DEBUG("uc_insert: Added %s to the cache.", key);
- return (0);
+ return 0;
} /* int uc_insert */
int uc_init(void) {
cache_tree =
c_avl_create((int (*)(const void *, const void *))cache_compare);
- return (0);
+ return 0;
} /* int uc_init */
int uc_check_timeout(void) {
if (expired_num == 0) {
sfree(expired);
- return (0);
+ return 0;
}
/* Call the "missing" callback for each value. Do this before removing the
pthread_mutex_unlock(&cache_lock);
sfree(expired);
- return (0);
+ return 0;
} /* int uc_check_timeout */
int uc_update(const data_set_t *ds, const value_list_t *vl) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("uc_update: FORMAT_VL failed.");
- return (-1);
+ return -1;
}
pthread_mutex_lock(&cache_lock);
{
status = uc_insert(ds, vl, name);
pthread_mutex_unlock(&cache_lock);
- return (status);
+ return status;
}
assert(ce != NULL);
"last cache update = %.3f;",
name, CDTIME_T_TO_DOUBLE(vl->time),
CDTIME_T_TO_DOUBLE(ce->last_time));
- return (-1);
+ return -1;
}
for (size_t i = 0; i < ds->ds_num; i++) {
pthread_mutex_unlock(&cache_lock);
ERROR("uc_update: Don't know how to handle data source type %i.",
ds->ds[i].type);
- return (-1);
+ return -1;
} /* switch (ds->ds[i].type) */
DEBUG("uc_update: %s: ds[%zu] = %lf", name, i, ce->values_gauge[i]);
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
} /* int uc_update */
int uc_get_rate_by_name(const char *name, gauge_t **ret_values,
*ret_values_num = ret_num;
}
- return (status);
+ return status;
} /* gauge_t *uc_get_rate_by_name */
gauge_t *uc_get_rate(const data_set_t *ds, const value_list_t *vl) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("utils_cache: uc_get_rate: FORMAT_VL failed.");
- return (NULL);
+ return NULL;
}
status = uc_get_rate_by_name(name, &ret, &ret_num);
if (status != 0)
- return (NULL);
+ return NULL;
/* This is important - the caller has no other way of knowing how many
* values are returned. */
"but uc_get_rate_by_name returned %zu.",
ds->type, ds->ds_num, ret_num);
sfree(ret);
- return (NULL);
+ return NULL;
}
- return (ret);
+ return ret;
} /* gauge_t *uc_get_rate */
size_t uc_get_size(void) {
size_arrays = (size_t)c_avl_size(cache_tree);
pthread_mutex_unlock(&cache_lock);
- return (size_arrays);
+ return size_arrays;
}
int uc_get_names(char ***ret_names, cdtime_t **ret_times, size_t *ret_number) {
int status = 0;
if ((ret_names == NULL) || (ret_number == NULL))
- return (-1);
+ return -1;
pthread_mutex_lock(&cache_lock);
/* Handle the "no values" case here, to avoid the error message when
* calloc() returns NULL. */
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
}
names = calloc(size_arrays, sizeof(*names));
sfree(names);
sfree(times);
pthread_mutex_unlock(&cache_lock);
- return (ENOMEM);
+ return ENOMEM;
}
iter = c_avl_get_iterator(cache_tree);
sfree(names);
sfree(times);
- return (-1);
+ return -1;
}
*ret_names = names;
sfree(times);
*ret_number = number;
- return (0);
+ return 0;
} /* int uc_get_names */
int uc_get_state(const data_set_t *ds, const value_list_t *vl) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("uc_get_state: FORMAT_VL failed.");
- return (STATE_ERROR);
+ return STATE_ERROR;
}
pthread_mutex_lock(&cache_lock);
pthread_mutex_unlock(&cache_lock);
- return (ret);
+ return ret;
} /* int uc_get_state */
int uc_set_state(const data_set_t *ds, const value_list_t *vl, int state) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("uc_set_state: FORMAT_VL failed.");
- return (STATE_ERROR);
+ return STATE_ERROR;
}
pthread_mutex_lock(&cache_lock);
pthread_mutex_unlock(&cache_lock);
- return (ret);
+ return ret;
} /* int uc_set_state */
int uc_get_history_by_name(const char *name, gauge_t *ret_history,
status = c_avl_get(cache_tree, name, (void *)&ce);
if (status != 0) {
pthread_mutex_unlock(&cache_lock);
- return (-ENOENT);
+ return -ENOENT;
}
if (((size_t)ce->values_num) != num_ds) {
pthread_mutex_unlock(&cache_lock);
- return (-EINVAL);
+ return -EINVAL;
}
/* Check if there are enough values available. If not, increase the buffer
realloc(ce->history, sizeof(*ce->history) * num_steps * ce->values_num);
if (tmp == NULL) {
pthread_mutex_unlock(&cache_lock);
- return (-ENOMEM);
+ return -ENOMEM;
}
for (size_t i = ce->history_length * ce->values_num;
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
} /* int uc_get_history_by_name */
int uc_get_history(const data_set_t *ds, const value_list_t *vl,
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("utils_cache: uc_get_history: FORMAT_VL failed.");
- return (-1);
+ return -1;
}
- return (uc_get_history_by_name(name, ret_history, num_steps, num_ds));
+ return uc_get_history_by_name(name, ret_history, num_steps, num_ds);
} /* int uc_get_history */
int uc_get_hits(const data_set_t *ds, const value_list_t *vl) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("uc_get_hits: FORMAT_VL failed.");
- return (STATE_ERROR);
+ return STATE_ERROR;
}
pthread_mutex_lock(&cache_lock);
pthread_mutex_unlock(&cache_lock);
- return (ret);
+ return ret;
} /* int uc_get_hits */
int uc_set_hits(const data_set_t *ds, const value_list_t *vl, int hits) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("uc_set_hits: FORMAT_VL failed.");
- return (STATE_ERROR);
+ return STATE_ERROR;
}
pthread_mutex_lock(&cache_lock);
pthread_mutex_unlock(&cache_lock);
- return (ret);
+ return ret;
} /* int uc_set_hits */
int uc_inc_hits(const data_set_t *ds, const value_list_t *vl, int step) {
if (FORMAT_VL(name, sizeof(name), vl) != 0) {
ERROR("uc_inc_hits: FORMAT_VL failed.");
- return (STATE_ERROR);
+ return STATE_ERROR;
}
pthread_mutex_lock(&cache_lock);
pthread_mutex_unlock(&cache_lock);
- return (ret);
+ return ret;
} /* int uc_inc_hits */
/*
iter = (uc_iter_t *)calloc(1, sizeof(*iter));
if (iter == NULL)
- return (NULL);
+ return NULL;
pthread_mutex_lock(&cache_lock);
iter->iter = c_avl_get_iterator(cache_tree);
if (iter->iter == NULL) {
free(iter);
- return (NULL);
+ return NULL;
}
- return (iter);
+ return iter;
} /* uc_iter_t *uc_get_iterator */
int uc_iterator_next(uc_iter_t *iter, char **ret_name) {
int status;
if (iter == NULL)
- return (-1);
+ return -1;
while ((status = c_avl_iterator_next(iter->iter, (void *)&iter->name,
(void *)&iter->entry)) == 0) {
if (status != 0) {
iter->name = NULL;
iter->entry = NULL;
- return (-1);
+ return -1;
}
if (ret_name != NULL)
*ret_name = iter->name;
- return (0);
+ return 0;
} /* int uc_iterator_next */
void uc_iterator_destroy(uc_iter_t *iter) {
int uc_iterator_get_time(uc_iter_t *iter, cdtime_t *ret_time) {
if ((iter == NULL) || (iter->entry == NULL) || (ret_time == NULL))
- return (-1);
+ return -1;
*ret_time = iter->entry->last_time;
- return (0);
+ return 0;
} /* int uc_iterator_get_name */
int uc_iterator_get_values(uc_iter_t *iter, value_t **ret_values,
size_t *ret_num) {
if ((iter == NULL) || (iter->entry == NULL) || (ret_values == NULL) ||
(ret_num == NULL))
- return (-1);
+ return -1;
*ret_values =
calloc(iter->entry->values_num, sizeof(*iter->entry->values_raw));
if (*ret_values == NULL)
- return (-1);
+ return -1;
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;
- return (0);
+ return 0;
} /* int uc_iterator_get_values */
int uc_iterator_get_interval(uc_iter_t *iter, cdtime_t *ret_interval) {
if ((iter == NULL) || (iter->entry == NULL) || (ret_interval == NULL))
- return (-1);
+ return -1;
*ret_interval = iter->entry->interval;
- return (0);
+ return 0;
} /* int uc_iterator_get_name */
/*
status = FORMAT_VL(name, sizeof(name), vl);
if (status != 0) {
ERROR("utils_cache: uc_get_meta: FORMAT_VL failed.");
- return (NULL);
+ return NULL;
}
pthread_mutex_lock(&cache_lock);
status = c_avl_get(cache_tree, name, (void *)&ce);
if (status != 0) {
pthread_mutex_unlock(&cache_lock);
- return (NULL);
+ return NULL;
}
assert(ce != NULL);
if (ce->meta == NULL)
pthread_mutex_unlock(&cache_lock);
- return (ce->meta);
+ return ce->meta;
} /* }}} meta_data_t *uc_get_meta */
/* Sorry about this preprocessor magic, but it really makes this file much
int status; \
meta = uc_get_meta(vl); \
if (meta == NULL) \
- return (-1); \
+ return -1; \
status = wrap_function(meta, key); \
pthread_mutex_unlock(&cache_lock); \
- return (status); \
+ return status; \
}
int uc_meta_data_exists(const value_list_t *vl,
const char *key) UC_WRAP(meta_data_exists)
int status; \
meta = uc_get_meta(vl); \
if (meta == NULL) \
- return (-1); \
+ return -1; \
status = wrap_function(meta, key, value); \
pthread_mutex_unlock(&cache_lock); \
- return (status); \
+ return status; \
}
int uc_meta_data_add_string(const value_list_t *vl, const char *key,
const char *value)
index 0f0077dfa5faceba2987779cb2f1da2819376735..5389d126d714088c4f9b211ded28277a10203a1f 100644 (file)
gauge_t *uc_get_rate(__attribute__((unused)) data_set_t const *ds,
__attribute__((unused)) value_list_t const *vl) {
errno = ENOTSUP;
- return (NULL);
+ return NULL;
}
int uc_get_rate_by_name(const char *name, gauge_t **ret_values,
size_t *ret_values_num) {
- return (ENOTSUP);
+ return ENOTSUP;
}
int uc_get_names(char ***ret_names, cdtime_t **ret_times, size_t *ret_number) {
- return (ENOTSUP);
+ return ENOTSUP;
}
index 3bae48ee2f03ebc4c5ada00c450544e07a02299b..d36d410bae5823423821041825be8a1f5ac58009 100644 (file)
--- a/src/daemon/utils_heap.c
+++ b/src/daemon/utils_heap.c
c_heap_t *h;
if (compare == NULL)
- return (NULL);
+ return NULL;
h = calloc(1, sizeof(*h));
if (h == NULL)
- return (NULL);
+ return NULL;
pthread_mutex_init(&h->lock, /* attr = */ NULL);
h->compare = compare;
h->list_len = 0;
h->list_size = 0;
- return (h);
+ return h;
} /* c_heap_t *c_heap_create */
void c_heap_destroy(c_heap_t *h) {
size_t index;
if ((h == NULL) || (ptr == NULL))
- return (-EINVAL);
+ return -EINVAL;
pthread_mutex_lock(&h->lock);
tmp = realloc(h->list, (h->list_size + 16) * sizeof(*h->list));
if (tmp == NULL) {
pthread_mutex_unlock(&h->lock);
- return (-ENOMEM);
+ return -ENOMEM;
}
h->list = tmp;
reheap(h, /* parent of this node = */ (index - 1) / 2, DIR_UP);
pthread_mutex_unlock(&h->lock);
- return (0);
+ return 0;
} /* int c_heap_insert */
void *c_heap_get_root(c_heap_t *h) {
void *ret = NULL;
if (h == NULL)
- return (NULL);
+ return NULL;
pthread_mutex_lock(&h->lock);
if (h->list_len == 0) {
pthread_mutex_unlock(&h->lock);
- return (NULL);
+ return NULL;
} else if (h->list_len == 1) {
ret = h->list[0];
h->list[0] = NULL;
pthread_mutex_unlock(&h->lock);
- return (ret);
+ return ret;
} /* void *c_heap_get_root */
index dec84f94bf0377b9b44118f47e54248db12eb590..827c090f512ddc51c9d3ab285d5b4926d32f5923 100644 (file)
}
c_heap_destroy(h);
- return (0);
+ return 0;
}
int main(void) {
index 2ed56a0258010d85101d3d0973b7465e740aee2e..61c6051b0a2bde817c0ebd31889e1a26b200d462 100644 (file)
--- a/src/daemon/utils_llist.c
+++ b/src/daemon/utils_llist.c
ret = calloc(1, sizeof(*ret));
if (ret == NULL)
- return (NULL);
+ return NULL;
- return (ret);
+ return ret;
}
void llist_destroy(llist_t *l) {
e->next = NULL;
}
- return (e);
+ return e;
}
void llentry_destroy(llentry_t *e) { free(e); }
--(l->size);
}
-int llist_size(llist_t *l) { return (l ? l->size : 0); }
+int llist_size(llist_t *l) { return l ? l->size : 0; }
static int llist_strcmp(llentry_t *e, void *ud) {
if ((e == NULL) || (ud == NULL))
- return (-1);
- return (strcmp(e->key, (const char *)ud));
+ return -1;
+ return strcmp(e->key, (const char *)ud);
}
llentry_t *llist_search(llist_t *l, const char *key) {
- return (llist_search_custom(l, llist_strcmp, (void *)key));
+ return llist_search_custom(l, llist_strcmp, (void *)key);
}
llentry_t *llist_search_custom(llist_t *l, int (*compare)(llentry_t *, void *),
llentry_t *e;
if (l == NULL)
- return (NULL);
+ return NULL;
e = l->head;
while (e != NULL) {
@@ -153,17 +153,17 @@ llentry_t *llist_search_custom(llist_t *l, int (*compare)(llentry_t *, void *),
e = next;
}
- return (e);
+ return e;
}
llentry_t *llist_head(llist_t *l) {
if (l == NULL)
- return (NULL);
- return (l->head);
+ return NULL;
+ return l->head;
}
llentry_t *llist_tail(llist_t *l) {
if (l == NULL)
- return (NULL);
- return (l->tail);
+ return NULL;
+ return l->tail;
}
index 77b500fb8faaf17397811069528560b3ea620572..cf926f9c81a150371d36af82547c6963ff92316f 100644 (file)
r = erand48(seed);
pthread_mutex_unlock(&lock);
- return (r);
+ return r;
}
uint32_t cdrand_u(void) {
r = (long)(0.5 + (cdrand_d() * range));
r += min;
- return (r);
+ return r;
}
index 523534324649ea0f807fcf3208219e1ac723b12b..a016342540cf95332074bcb395a6564adc512316 100644 (file)
--- a/src/daemon/utils_subst.c
+++ b/src/daemon/utils_subst.c
if ((buf == NULL) || (string == NULL) || (needle == NULL) ||
(replacement == NULL))
- return (NULL);
+ return NULL;
needle_len = strlen(needle);
sstrncpy(buf, string, buflen);
i, string, needle, replacement);
}
- return (buf);
+ return buf;
} /* char *subst_string */
index ad832f544efbeba59a27c6736e07beffaeed98ab..8c03341148af5931269f8d088cad132be04affb4 100644 (file)
name[sizeof(name) - 1] = '\0';
if (c_avl_get(threshold_tree, name, (void *)&th) == 0)
- return (th);
+ return th;
else
- return (NULL);
+ return NULL;
} /* }}} threshold_t *threshold_get */
/*
if ((th = threshold_get(vl->host, vl->plugin, vl->plugin_instance, vl->type,
vl->type_instance)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get(vl->host, vl->plugin, vl->plugin_instance,
vl->type, NULL)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get(vl->host, vl->plugin, NULL, vl->type,
vl->type_instance)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get(vl->host, vl->plugin, NULL, vl->type, NULL)) !=
NULL)
- return (th);
+ return th;
else if ((th = threshold_get(vl->host, "", NULL, vl->type,
vl->type_instance)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get(vl->host, "", NULL, vl->type, NULL)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get("", vl->plugin, vl->plugin_instance, vl->type,
vl->type_instance)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get("", vl->plugin, vl->plugin_instance, vl->type,
NULL)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get("", vl->plugin, NULL, vl->type,
vl->type_instance)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get("", vl->plugin, NULL, vl->type, NULL)) != NULL)
- return (th);
+ return th;
else if ((th = threshold_get("", "", NULL, vl->type, vl->type_instance)) !=
NULL)
- return (th);
+ return th;
else if ((th = threshold_get("", "", NULL, vl->type, NULL)) != NULL)
- return (th);
+ return th;
- return (NULL);
+ return NULL;
} /* }}} threshold_t *threshold_search */
int ut_search_threshold(const value_list_t *vl, /* {{{ */
threshold_t *t;
if (vl == NULL)
- return (EINVAL);
+ return EINVAL;
/* Is this lock really necessary? */
pthread_mutex_lock(&threshold_lock);
t = threshold_search(vl);
if (t == NULL) {
pthread_mutex_unlock(&threshold_lock);
- return (ENOENT);
+ return ENOENT;
}
memcpy(ret_threshold, t, sizeof(*ret_threshold));
ret_threshold->next = NULL;
- return (0);
+ return 0;
} /* }}} int ut_search_threshold */
diff --git a/src/dbi.c b/src/dbi.c
index 2b374e9fad801aa0b7539fb12b210d9a4c2e9c28..ac307ff2e01f57f00268c77870c8991b28323892 100644 (file)
--- a/src/dbi.c
+++ b/src/dbi.c
if (conn == NULL) {
sstrncpy(buffer, "connection is NULL", buffer_size);
- return (buffer);
+ return buffer;
}
msg = NULL;
ssnprintf(buffer, buffer_size, "dbi_conn_error failed with status %i",
status);
- return (buffer);
+ return buffer;
} /* }}} const char *cdbi_conn_error */
static int cdbi_result_get_field(dbi_result res, /* {{{ */
if (src_type == DBI_TYPE_ERROR) {
ERROR("dbi plugin: cdbi_result_get: "
"dbi_result_get_field_type_idx failed.");
- return (-1);
+ return -1;
}
if (src_type == DBI_TYPE_INTEGER) {
if (value == NULL)
sstrncpy(buffer, "", buffer_size);
else if (strcmp("ERROR", value) == 0)
- return (-1);
+ return -1;
else
sstrncpy(buffer, value, buffer_size);
}
ERROR("dbi plugin: Column `%s': Don't know how to handle "
"source type %hu.",
field_name, src_type);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cdbi_result_get_field */
static void cdbi_database_free(cdbi_database_t *db) /* {{{ */
@@ -221,14 +221,14 @@ static int cdbi_config_add_database_driver_option(cdbi_database_t *db, /* {{{ */
(ci->values[1].type != OCONFIG_TYPE_NUMBER))) {
WARNING("dbi plugin: The `DriverOption' config option "
"needs exactly two arguments.");
- return (-1);
+ return -1;
}
option = realloc(db->driver_options,
sizeof(*option) * (db->driver_options_num + 1));
if (option == NULL) {
ERROR("dbi plugin: realloc failed");
- return (-1);
+ return -1;
}
db->driver_options = option;
@@ -238,7 +238,7 @@ static int cdbi_config_add_database_driver_option(cdbi_database_t *db, /* {{{ */
option->key = strdup(ci->values[0].value.string);
if (option->key == NULL) {
ERROR("dbi plugin: strdup failed.");
- return (-1);
+ return -1;
}
if (ci->values[1].type == OCONFIG_TYPE_STRING) {
@@ -246,7 +246,7 @@ static int cdbi_config_add_database_driver_option(cdbi_database_t *db, /* {{{ */
if (option->value.string == NULL) {
ERROR("dbi plugin: strdup failed.");
sfree(option->key);
- return (-1);
+ return -1;
}
} else {
assert(ci->values[1].type == OCONFIG_TYPE_NUMBER);
@@ -255,7 +255,7 @@ static int cdbi_config_add_database_driver_option(cdbi_database_t *db, /* {{{ */
}
db->driver_options_num++;
- return (0);
+ return 0;
} /* }}} int cdbi_config_add_database_driver_option */
static int cdbi_config_add_database(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("dbi plugin: The `Database' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
db = calloc(1, sizeof(*db));
if (db == NULL) {
ERROR("dbi plugin: calloc failed.");
- return (-1);
+ return -1;
}
status = cf_util_get_string(ci, &db->name);
if (status != 0) {
sfree(db);
- return (status);
+ return status;
}
/* Fill the `cdbi_database_t' structure.. */
if (status != 0) {
cdbi_database_free(db);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cdbi_config_add_database */
static int cdbi_config(oconfig_item_t *ci) /* {{{ */
}
} /* for (ci->children) */
- return (0);
+ return 0;
} /* }}} int cdbi_config */
/* }}} End of configuration handling functions */
int status;
if (did_init != 0)
- return (0);
+ return 0;
if (queries_num == 0) {
ERROR("dbi plugin: No <Query> blocks have been found. Without them, "
"this plugin can't do anything useful, so we will return an error.");
- return (-1);
+ return -1;
}
if (databases_num == 0) {
ERROR("dbi plugin: No <Database> blocks have been found. Without them, "
"this plugin can't do anything useful, so we will return an error.");
- return (-1);
+ return -1;
}
status = dbi_initialize_r(/* driverdir = */ NULL, &dbi_instance);
if (status < 0) {
ERROR("dbi plugin: cdbi_init: dbi_initialize_r failed with status %i.",
status);
- return (-1);
+ return -1;
} else if (status == 0) {
ERROR("dbi plugin: `dbi_initialize_r' could not load any drivers. Please "
"install at least one `DBD' or check your installation.");
- return (-1);
+ return -1;
}
DEBUG("dbi plugin: cdbi_init: dbi_initialize_r reports %i driver%s.", status,
(status == 1) ? "" : "s");
- return (0);
+ return 0;
} /* }}} int cdbi_init */
static int cdbi_read_database_query(cdbi_database_t *db, /* {{{ */
if (db->connection != NULL) {
status = dbi_conn_ping(db->connection);
if (status != 0) /* connection is alive */
- return (0);
+ return 0;
dbi_conn_close(db->connection);
db->connection = NULL;
driver = dbi_driver_list_r(driver, dbi_instance)) {
INFO("dbi plugin: * %s", dbi_driver_get_name(driver));
}
- return (-1);
+ return -1;
}
connection = dbi_conn_open(driver);
if (connection == NULL) {
ERROR("dbi plugin: cdbi_connect_database: dbi_conn_open (%s) failed.",
db->driver);
- return (-1);
+ return -1;
}
/* Set all the driver options. Because this is a very very very generic
}
dbi_conn_close(connection);
- return (-1);
+ return -1;
}
} /* for (i = 0; i < db->driver_options_num; i++) */
"dbi_conn_connect failed: %s",
db->name, cdbi_strerror(connection, errbuf, sizeof(errbuf)));
dbi_conn_close(connection);
- return (-1);
+ return -1;
}
if (db->select_db != NULL) {
db->name, db->select_db,
cdbi_strerror(connection, errbuf, sizeof(errbuf)));
dbi_conn_close(connection);
- return (-1);
+ return -1;
}
}
db->connection = connection;
- return (0);
+ return 0;
} /* }}} int cdbi_connect_database */
static int cdbi_read_database(user_data_t *ud) /* {{{ */
status = cdbi_connect_database(db);
if (status != 0)
- return (status);
+ return status;
assert(db->connection != NULL);
db_version = dbi_conn_get_engine_version(db->connection);
if (success == 0) {
ERROR("dbi plugin: All queries failed for database `%s'.", db->name);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cdbi_read_database */
static int cdbi_shutdown(void) /* {{{ */
queries = NULL;
queries_num = 0;
- return (0);
+ return 0;
} /* }}} int cdbi_shutdown */
void module_register(void) /* {{{ */
diff --git a/src/df.c b/src/df.c
index 541660523a305bb9ccad2f1d5ca3d100b51ad184..dd90f243343396ec5742288bceff12d4e34e5de6 100644 (file)
--- a/src/df.c
+++ b/src/df.c
if (il_fstype == NULL)
il_fstype = ignorelist_create(1);
- return (0);
+ return 0;
}
static int df_config(const char *key, const char *value) {
if (strcasecmp(key, "Device") == 0) {
if (ignorelist_add(il_device, value))
- return (1);
- return (0);
+ return 1;
+ return 0;
} else if (strcasecmp(key, "MountPoint") == 0) {
if (ignorelist_add(il_mountpoint, value))
- return (1);
- return (0);
+ return 1;
+ return 0;
} else if (strcasecmp(key, "FSType") == 0) {
if (ignorelist_add(il_fstype, value))
- return (1);
- return (0);
+ return 1;
+ return 0;
} else if (strcasecmp(key, "IgnoreSelected") == 0) {
if (IS_TRUE(value)) {
ignorelist_set_invert(il_device, 0);
ignorelist_set_invert(il_mountpoint, 1);
ignorelist_set_invert(il_fstype, 1);
}
- return (0);
+ return 0;
} else if (strcasecmp(key, "ReportByDevice") == 0) {
if (IS_TRUE(value))
by_device = 1;
- return (0);
+ return 0;
} else if (strcasecmp(key, "ReportInodes") == 0) {
if (IS_TRUE(value))
report_inodes = 1;
else
report_inodes = 0;
- return (0);
+ return 0;
} else if (strcasecmp(key, "ValuesAbsolute") == 0) {
if (IS_TRUE(value))
values_absolute = 1;
else
values_absolute = 0;
- return (0);
+ return 0;
} else if (strcasecmp(key, "ValuesPercentage") == 0) {
if (IS_TRUE(value))
values_percentage = 1;
else
values_percentage = 0;
- return (0);
+ return 0;
}
- return (-1);
+ return -1;
}
__attribute__((nonnull(2))) static void df_submit_one(char *plugin_instance,
mnt_list = NULL;
if (cu_mount_getlist(&mnt_list) == NULL) {
ERROR("df plugin: cu_mount_getlist failed.");
- return (-1);
+ return -1;
}
for (cu_mount_t *mnt_ptr = mnt_list; mnt_ptr != NULL;
df_submit_one(disk_name, "percent_bytes", "used",
(gauge_t)((float_t)(blk_used) / statbuf.f_blocks * 100));
} else
- return (-1);
+ return -1;
}
/* inode handling */
disk_name, "percent_inodes", "used",
(gauge_t)((float_t)(inode_used) / statbuf.f_files * 100));
} else
- return (-1);
+ return -1;
}
if (values_absolute) {
df_submit_one(disk_name, "df_inodes", "free", (gauge_t)inode_free);
cu_mount_freelist(mnt_list);
- return (0);
+ return 0;
} /* int df_read */
void module_register(void) {
diff --git a/src/disk.c b/src/disk.c
index 58a1c189563f4d5ff5fcb01331b0f1eef51d9e5a..4a217c30ff58dca99bd6c00343a3469df13d7245 100644 (file)
--- a/src/disk.c
+++ b/src/disk.c
if (ignorelist == NULL)
ignorelist = ignorelist_create(/* invert = */ 1);
if (ignorelist == NULL)
- return (1);
+ return 1;
if (strcasecmp("Disk", key) == 0) {
ignorelist_add(ignorelist, value);
conf_udev_name_attr = NULL;
}
if ((conf_udev_name_attr = strdup(value)) == NULL)
- return (1);
+ return 1;
#else
WARNING("disk plugin: The \"UdevNameAttr\" option is only supported "
"if collectd is built with libudev support");
#endif
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int disk_config */
static int disk_init(void) {
if (status != kIOReturnSuccess) {
ERROR("IOMasterPort failed: %s", mach_error_string(status));
io_master_port = MACH_PORT_NULL;
- return (-1);
+ return -1;
}
/* #endif HAVE_IOKIT_IOKITLIB_H */
handle_udev = udev_new();
if (handle_udev == NULL) {
ERROR("disk plugin: udev_new() failed!");
- return (-1);
+ return -1;
}
}
#endif /* HAVE_UDEV_H */
rv = geom_gettree(&geom_tree);
if (rv != 0) {
ERROR("geom_gettree() failed, returned %d", rv);
- return (-1);
+ return -1;
}
rv = geom_stats_open();
if (rv != 0) {
ERROR("geom_stats_open() failed, returned %d", rv);
- return (-1);
+ return -1;
}
/* #endif KERNEL_FREEBSD */
numdisk = 0;
if (kc == NULL)
- return (-1);
+ return -1;
for (numdisk = 0, ksp_chain = kc->kc_chain;
(numdisk < MAX_NUMDISK) && (ksp_chain != NULL);
}
#endif /* HAVE_LIBKSTAT */
- return (0);
+ return 0;
} /* int disk_init */
static int disk_shutdown(void) {
udev_unref(handle_udev);
#endif /* HAVE_UDEV_H */
#endif /* KERNEL_LINUX */
- return (0);
+ return 0;
} /* int disk_shutdown */
static void disk_submit(const char *plugin_instance, const char *type,
double avg_time = ((double)delta_time) / ((double)delta_ops);
double avg_time_incr = interval * avg_time;
- return ((counter_t)(avg_time_incr + .5));
+ return (counter_t)(avg_time_incr + .5);
}
#endif
kCFStringEncodingASCII);
if (key_obj == NULL) {
DEBUG("CFStringCreateWithCString (%s) failed.", key);
- return (-1LL);
+ return -1LL;
}
/* get => we don't need to release (== free) the object */
@@ -373,15 +373,15 @@ static signed long long dict_get_value(CFDictionaryRef dict, const char *key) {
if (val_obj == NULL) {
DEBUG("CFDictionaryGetValue (%s) failed.", key);
- return (-1LL);
+ return -1LL;
}
if (!CFNumberGetValue(val_obj, kCFNumberSInt64Type, &val_int)) {
DEBUG("CFNumberGetValue (%s) failed.", key);
- return (-1LL);
+ return -1LL;
}
- return (val_int);
+ return val_int;
}
#endif /* HAVE_IOKIT_IOKITLIB_H */
/* Get the list of all disk objects. */
if (IOServiceGetMatchingServices(
- io_master_port, IOServiceMatching(kIOBlockStorageDriverClass),
- &disk_list) != kIOReturnSuccess) {
+ io_master_port, IOServiceMatching(kIOBlockStorageDriverClass),
+ &disk_list) != kIOReturnSuccess) {
ERROR("disk plugin: IOServiceGetMatchingServices failed.");
- return (-1);
+ return -1;
}
while ((disk = IOIteratorNext(disk_list)) != 0) {
snap = geom_stats_snapshot_get();
if (snap == NULL) {
ERROR("disk plugin: geom_stats_snapshot_get() failed.");
- return (-1);
+ return -1;
}
/* Check if we have dirty read from this snapshot */
if (geom_gettree(&geom_tree) != 0) {
ERROR("disk plugin: geom_gettree() failed");
geom_stats_snapshot_free(snap);
- return (-1);
+ return -1;
}
geom_id = geom_lookupid(&geom_tree, snap_iter->id);
}
fh = fopen("/proc/partitions", "r");
if (fh == NULL) {
ERROR("disk plugin: fopen (/proc/{diskstats,partitions}) failed.");
- return (-1);
+ return -1;
}
/* Kernel is 2.4.* */
static kstat_io_t kio;
if (kc == NULL)
- return (-1);
+ return -1;
for (int i = 0; i < numdisk; i++) {
if (kstat_read(kc, ksp[i], &kio) == -1)
char name[DATA_MAX_NAME_LEN];
if ((ds = sg_get_disk_io_stats(&disks)) == NULL)
- return (0);
+ return 0;
for (int counter = 0; counter < disks; counter++) {
strncpy(name, ds->disk_name, sizeof(name));
char errbuf[1024];
WARNING("disk plugin: perfstat_disk: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (numdisk != pnumdisk || stat_disk == NULL) {
char errbuf[1024];
WARNING("disk plugin: perfstat_disk : %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (int i = 0; i < rnumdisk; i++) {
}
#endif /* defined(HAVE_PERFSTAT) */
- return (0);
+ return 0;
} /* int disk_read */
void module_register(void) {
diff --git a/src/dns.c b/src/dns.c
index e3208a68e5c187e064539e73e37e662a18c0349d..e64af0dd8440ac3bb63c9ae632ecc54404834701 100644 (file)
--- a/src/dns.c
+++ b/src/dns.c
if (entry->key == key)
break;
- return (entry);
+ return entry;
}
static counter_list_t *counter_list_create(counter_list_t **list,
entry = calloc(1, sizeof(*entry));
if (entry == NULL)
- return (NULL);
+ return NULL;
entry->key = key;
entry->value = value;
last->next = entry;
}
- return (entry);
+ return entry;
}
static void counter_list_add(counter_list_t **list, unsigned int key,
if (pcap_device != NULL)
free(pcap_device);
if ((pcap_device = strdup(value)) == NULL)
- return (1);
+ return 1;
} else if (strcasecmp(key, "IgnoreSource") == 0) {
if (value != NULL)
ignore_list_add_name(value);
else
select_numeric_qtype = 1;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void dns_child_callback(const rfc1035_header_t *dns) {
ERROR("dns plugin: Opening interface `%s' "
"failed: %s",
(pcap_device != NULL) ? pcap_device : "any", pcap_error);
- return (PCAP_ERROR);
+ return PCAP_ERROR;
}
status = pcap_compile(pcap_obj, &fp, "udp port 53", 1, 0);
if (status < 0) {
ERROR("dns plugin: pcap_compile failed: %s", pcap_statustostr(status));
- return (status);
+ return status;
}
status = pcap_setfilter(pcap_obj, &fp);
if (status < 0) {
ERROR("dns plugin: pcap_setfilter failed: %s", pcap_statustostr(status));
- return (status);
+ return status;
}
DEBUG("dns plugin: PCAP object created.");
status = PCAP_ERROR_IFACE_NOT_UP;
pcap_close(pcap_obj);
- return (status);
+ return status;
} /* int dns_run_pcap_loop */
static int dns_sleep_one_interval(void) /* {{{ */
if ((errno == EINTR) || (errno == EAGAIN))
continue;
- return (errno);
+ return errno;
}
- return (0);
+ return 0;
} /* }}} int dns_sleep_one_interval */
static void *dns_child_loop(__attribute__((unused)) void *dummy) /* {{{ */
ERROR("dns plugin: PCAP returned error %s.", pcap_statustostr(status));
listen_thread_init = 0;
- return (NULL);
+ return NULL;
} /* }}} void *dns_child_loop */
static int dns_init(void) {
pthread_mutex_unlock(&traffic_mutex);
if (listen_thread_init != 0)
- return (-1);
+ return -1;
status = plugin_thread_create(&listen_thread, NULL, dns_child_loop, (void *)0,
"dns listen");
char errbuf[1024];
ERROR("dns plugin: pthread_create failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
listen_thread_init = 1;
}
#endif
- return (0);
+ return 0;
} /* int dns_init */
static void submit_derive(const char *type, const char *type_instance,
submit_derive("dns_rcode", rcode_str(keys[i]), values[i]);
}
- return (0);
+ return 0;
} /* int dns_read */
void module_register(void) {
diff --git a/src/dpdkstat.c b/src/dpdkstat.c
index cfe993cbeeb2d547537eb201be55738f4b15e5f6..cc525e82c7b08d1bb7dae201144be0ddce92172b 100644 (file)
--- a/src/dpdkstat.c
+++ b/src/dpdkstat.c
}
static int dpdk_stats_get_size(dpdk_helper_ctx_t *phc) {
- return (dpdk_helper_data_size_get(phc) - sizeof(dpdk_stats_ctx_t));
+ return dpdk_helper_data_size_get(phc) - sizeof(dpdk_stats_ctx_t);
}
int dpdk_helper_command_handler(dpdk_helper_ctx_t *phc, enum DPDK_CMD cmd) {
diff --git a/src/drbd.c b/src/drbd.c
index 2ee16567a6f0f2e2ba6a8d9250049222db4583f3..97a4f03247bad49e8bc664230865323086caae1c 100644 (file)
--- a/src/drbd.c
+++ b/src/drbd.c
};
static size_t drbd_names_num = STATIC_ARRAY_SIZE(drbd_names);
-static int drbd_init(void) { return (0); }
+static int drbd_init(void) { return 0; }
static int drbd_submit_fields(long int resource, char **fields,
size_t fields_num) {
if (resource < 0) {
WARNING("drbd plugin: Unable to parse resource");
- return (EINVAL);
+ return EINVAL;
}
if (fields_num != drbd_names_num) {
WARNING("drbd plugin: Wrong number of fields for "
"r%ld statistics. Expected %zu, got %zu.",
resource, drbd_names_num, fields_num);
- return (EINVAL);
+ return EINVAL;
}
ssnprintf(plugin_instance, sizeof(plugin_instance), "r%ld", resource);
continue;
data = strchr(fields[i], ':');
if (data == NULL)
- return (EINVAL);
+ return EINVAL;
(void)parse_value(++data, &values[i], DS_TYPE_DERIVE);
}
plugin_dispatch_values(&vl);
}
- return (0);
+ return 0;
} /* drbd_submit_fields */
static int drbd_read(void) {
fh = fopen(drbd_stats, "r");
if (fh == NULL) {
WARNING("drbd plugin: Unable to open %s", drbd_stats);
- return (EINVAL);
+ return EINVAL;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
} /* while (fgets) */
fclose(fh);
- return (0);
+ return 0;
} /* void drbd_read */
void module_register(void) {
diff --git a/src/email.c b/src/email.c
index 72a8d6e747bdaaa3331a5cd6e8abffd0c06177d1..871ddf8b997b93cbc6484b904cbfd18de7f91372 100644 (file)
--- a/src/email.c
+++ b/src/email.c
} /* while (1) */
pthread_exit((void *)0);
- return ((void *)0);
+ return (void *)0;
} /* static void *collect (void *) */
static void *open_connection(void __attribute__((unused)) * arg) {
}
pthread_exit((void *)0);
- return ((void *)0);
+ return (void *)0;
} /* static void *open_connection (void *) */
static int email_init(void) {
disabled = 1;
log_err("plugin_thread_create() failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int email_init */
static void type_list_free(type_list_t *t) {
sfree(sock_file);
sfree(sock_group);
- return (0);
+ return 0;
} /* static void email_shutdown (void) */
static void email_submit(const char *type, const char *type_instance,
int score_count_old;
if (disabled)
- return (-1);
+ return -1;
/* email count */
pthread_mutex_lock(&count_mutex);
for (type_t *ptr = list_check_copy.head; NULL != ptr; ptr = ptr->next)
email_submit("spam_check", ptr->name, ptr->value);
- return (0);
+ return 0;
} /* int email_read */
void module_register(void) {
diff --git a/src/entropy.c b/src/entropy.c
index de35291c1955f540a661885e27f7b9b9061ea2e2..c7b5b3f3bbc3f2d3af0fe1d31ce1da7dd498416a 100644 (file)
--- a/src/entropy.c
+++ b/src/entropy.c
value_t v;
if (parse_value_file(ENTROPY_FILE, &v, DS_TYPE_GAUGE) != 0) {
ERROR("entropy plugin: Reading \"" ENTROPY_FILE "\" failed.");
- return (-1);
+ return -1;
}
entropy_submit(v);
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/ethstat.c b/src/ethstat.c
index 4b05300867607135a83c0276e90caf6c0c2113c3..3c03e36ab6134a20b2a42a0dcb081d7457f5be4a 100644 (file)
--- a/src/ethstat.c
+++ b/src/ethstat.c
tmp = realloc(interfaces, sizeof(*interfaces) * (interfaces_num + 1));
if (tmp == NULL)
- return (-1);
+ return -1;
interfaces = tmp;
interfaces[interfaces_num] = NULL;
status = cf_util_get_string(ci, interfaces + interfaces_num);
if (status != 0)
- return (status);
+ return status;
interfaces_num++;
INFO("ethstat plugin: Registered interface %s",
interfaces[interfaces_num - 1]);
- return (0);
+ return 0;
} /* }}} int ethstat_add_interface */
static int ethstat_add_map(const oconfig_item_t *ci) /* {{{ */
ERROR("ethstat plugin: The %s option requires "
"two or three string arguments.",
ci->key);
- return (-1);
+ return -1;
}
key = strdup(ci->values[0].value.string);
if (key == NULL) {
ERROR("ethstat plugin: strdup(3) failed.");
- return (ENOMEM);
+ return ENOMEM;
}
map = calloc(1, sizeof(*map));
if (map == NULL) {
sfree(key);
ERROR("ethstat plugin: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
sstrncpy(map->type, ci->values[1].value.string, sizeof(map->type));
sfree(map);
sfree(key);
ERROR("ethstat plugin: c_avl_create() failed.");
- return (-1);
+ return -1;
}
}
sfree(map);
sfree(key);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int ethstat_add_map */
static int ethstat_config(oconfig_item_t *ci) /* {{{ */
child->key);
}
- return (0);
+ return 0;
} /* }}} */
static void ethstat_submit_value(const char *device, const char *type_instance,
ERROR("ethstat plugin: Failed to get driver information "
"from %s: %s",
device, sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
n_stats = (size_t)drvinfo.n_stats;
if (n_stats < 1) {
close(fd);
ERROR("ethstat plugin: No stats available for %s", device);
- return (-1);
+ return -1;
}
strings_size = sizeof(struct ethtool_gstrings) + (n_stats * ETH_GSTRING_LEN);
sfree(strings);
sfree(stats);
ERROR("ethstat plugin: malloc failed.");
- return (-1);
+ return -1;
}
strings->cmd = ETHTOOL_GSTRINGS;
free(stats);
ERROR("ethstat plugin: Cannot get strings from %s: %s", device,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
stats->cmd = ETHTOOL_GSTATS;
free(stats);
ERROR("ethstat plugin: Reading statistics from %s failed: %s", device,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (size_t i = 0; i < n_stats; i++) {
sfree(strings);
sfree(stats);
- return (0);
+ return 0;
} /* }}} ethstat_read_interface */
static int ethstat_read(void) {
void *value = NULL;
if (value_map == NULL)
- return (0);
+ return 0;
while (c_avl_pick(value_map, &key, &value) == 0) {
sfree(key);
c_avl_destroy(value_map);
value_map = NULL;
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/exec.c b/src/exec.c
index df057189e47678fa722d3ca672d16215ba0034ba..f10b816b2c9dd7d19bc6d2b35f6815f1727f2a5d 100644 (file)
--- a/src/exec.c
+++ b/src/exec.c
if (ci->children_num != 0) {
WARNING("exec plugin: The config option `%s' may not be a block.", ci->key);
- return (-1);
+ return -1;
}
if (ci->values_num < 2) {
WARNING("exec plugin: The config option `%s' needs at least two "
"arguments.",
ci->key);
- return (-1);
+ return -1;
}
if ((ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
WARNING("exec plugin: The first two arguments to the `%s' option must "
"be string arguments.",
ci->key);
- return (-1);
+ return -1;
}
pl = calloc(1, sizeof(*pl));
if (pl == NULL) {
ERROR("exec plugin: calloc failed.");
- return (-1);
+ return -1;
}
if (strcasecmp("NotificationExec", ci->key) == 0)
if (pl->user == NULL) {
ERROR("exec plugin: strdup failed.");
sfree(pl);
- return (-1);
+ return -1;
}
pl->group = strchr(pl->user, ':');
ERROR("exec plugin: strdup failed.");
sfree(pl->user);
sfree(pl);
- return (-1);
+ return -1;
}
pl->argv = calloc(ci->values_num, sizeof(*pl->argv));
sfree(pl->exec);
sfree(pl->user);
sfree(pl);
- return (-1);
+ return -1;
}
{
sfree(pl->exec);
sfree(pl->user);
sfree(pl);
- return (-1);
+ return -1;
}
for (i = 1; i < (ci->values_num - 1); i++) {
sfree(pl->exec);
sfree(pl->user);
sfree(pl);
- return (-1);
+ return -1;
}
for (i = 0; pl->argv[i] != NULL; i++) {
pl->next = pl_head;
pl_head = pl;
- return (0);
+ return 0;
} /* int exec_config_exec }}} */
static int exec_config(oconfig_item_t *ci) /* {{{ */
}
} /* for (i) */
- return (0);
+ return 0;
} /* int exec_config }}} */
static void set_environment(void) /* {{{ */
if (status != 0) {
ERROR("exec plugin: pipe failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
return 0;
char nambuf[2048];
if (pl->pid != 0)
- return (-1);
+ return -1;
if ((create_pipe(fd_pipe_in) == -1) || (create_pipe(fd_pipe_out) == -1) ||
(create_pipe(fd_pipe_err) == -1))
else
close(fd_pipe_err[0]);
- return (pid);
+ return pid;
failed:
close_pipe(fd_pipe_in);
close_pipe(fd_pipe_out);
close_pipe(fd_pipe_err);
- return (-1);
+ return -1;
} /* int fork_child }}} */
static int parse_line(char *buffer) /* {{{ */
{
if (strncasecmp("PUTVAL", buffer, strlen("PUTVAL")) == 0)
- return (cmd_handle_putval(stdout, buffer));
+ return cmd_handle_putval(stdout, buffer);
else if (strncasecmp("PUTNOTIF", buffer, strlen("PUTNOTIF")) == 0)
- return (handle_putnotif(stdout, buffer));
+ return handle_putnotif(stdout, buffer);
else {
ERROR("exec plugin: Unable to parse command, ignoring line: \"%s\"",
buffer);
- return (-1);
+ return -1;
}
} /* int parse_line }}} */
close(fd_err);
pthread_exit((void *)0);
- return (NULL);
+ return NULL;
} /* void *exec_read_one }}} */
static void *exec_notification_one(void *arg) /* {{{ */
n->meta = NULL;
sfree(arg);
pthread_exit((void *)0);
- return (NULL);
+ return NULL;
} /* void *exec_notification_one }}} */
static int exec_init(void) /* {{{ */
}
#endif
- return (0);
+ return 0;
} /* int exec_init }}} */
static int exec_read(void) /* {{{ */
pthread_attr_destroy(&attr);
} /* for (pl) */
- return (0);
+ return 0;
} /* int exec_read }}} */
static int exec_notification(const notification_t *n, /* {{{ */
pthread_attr_destroy(&attr);
} /* for (pl) */
- return (0);
+ return 0;
} /* }}} int exec_notification */
static int exec_shutdown(void) /* {{{ */
} /* while (pl) */
pl_head = NULL;
- return (0);
+ return 0;
} /* int exec_shutdown }}} */
void module_register(void) {
diff --git a/src/fhcount.c b/src/fhcount.c
index 92107839218efc0105b389584a1ca7db29bddc09..36115305ed302e74076197d81bc3bedfb10d12d2 100644 (file)
--- a/src/fhcount.c
+++ b/src/fhcount.c
ret = 0;
}
- return (ret);
+ return ret;
}
static void fhcount_submit(const char *type, const char *type_instance,
fp = fopen("/proc/sys/fs/file-nr", "r");
if (fp == NULL) {
ERROR("fhcount: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (EXIT_FAILURE);
+ return EXIT_FAILURE;
}
if (fgets(buffer, buffer_len, fp) == NULL) {
ERROR("fhcount: fgets: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
fclose(fp);
- return (EXIT_FAILURE);
+ return EXIT_FAILURE;
}
fclose(fp);
if (numfields != 3) {
ERROR("fhcount: Line doesn't contain 3 fields");
- return (EXIT_FAILURE);
+ return EXIT_FAILURE;
}
// Define the values
fhcount_submit("percent", "unused", (gauge_t)prc_unused);
}
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/filecount.c b/src/filecount.c
index 608218df31b77c96d165f9f90ac5aae85b2be17e..7eb510475eaab13dba2cf0dc90850dbc1d9ba5ed 100644 (file)
--- a/src/filecount.c
+++ b/src/filecount.c
@@ -105,16 +105,16 @@ static int fc_config_set_instance(fc_directory_conf_t *dir, const char *str) {
/* do nothing */;
if (*ptr == 0)
- return (-1);
+ return -1;
copy = strdup(ptr);
if (copy == NULL)
- return (-1);
+ return -1;
sfree(dir->instance);
dir->instance = copy;
- return (0);
+ return 0;
} /* int fc_config_set_instance */
static int fc_config_add_dir_instance(fc_directory_conf_t *dir,
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("filecount plugin: The `Instance' config option needs exactly "
"one string argument.");
- return (-1);
+ return -1;
}
- return (fc_config_set_instance(dir, ci->values[0].value.string));
+ return fc_config_set_instance(dir, ci->values[0].value.string);
} /* int fc_config_add_dir_instance */
static int fc_config_add_dir_name(fc_directory_conf_t *dir,
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("filecount plugin: The `Name' config option needs exactly one "
"string argument.");
- return (-1);
+ return -1;
}
temp = strdup(ci->values[0].value.string);
if (temp == NULL) {
ERROR("filecount plugin: strdup failed.");
- return (-1);
+ return -1;
}
sfree(dir->name);
dir->name = temp;
- return (0);
+ return 0;
} /* int fc_config_add_dir_name */
static int fc_config_add_dir_mtime(fc_directory_conf_t *dir,
(ci->values[0].type != OCONFIG_TYPE_NUMBER))) {
WARNING("filecount plugin: The `MTime' config option needs exactly one "
"string or numeric argument.");
- return (-1);
+ return -1;
}
if (ci->values[0].type == OCONFIG_TYPE_NUMBER) {
dir->mtime = (int64_t)ci->values[0].value.number;
- return (0);
+ return 0;
}
errno = 0;
(endptr == ci->values[0].value.string)) {
WARNING("filecount plugin: Converting `%s' to a number failed.",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
switch (*endptr) {
default:
WARNING("filecount plugin: Invalid suffix for `MTime': `%c'", *endptr);
- return (-1);
+ return -1;
} /* switch (*endptr) */
dir->mtime = (int64_t)temp;
- return (0);
+ return 0;
} /* int fc_config_add_dir_mtime */
static int fc_config_add_dir_size(fc_directory_conf_t *dir,
(ci->values[0].type != OCONFIG_TYPE_NUMBER))) {
WARNING("filecount plugin: The `Size' config option needs exactly one "
"string or numeric argument.");
- return (-1);
+ return -1;
}
if (ci->values[0].type == OCONFIG_TYPE_NUMBER) {
dir->size = (int64_t)ci->values[0].value.number;
- return (0);
+ return 0;
}
errno = 0;
(endptr == ci->values[0].value.string)) {
WARNING("filecount plugin: Converting `%s' to a number failed.",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
switch (*endptr) {
default:
WARNING("filecount plugin: Invalid suffix for `Size': `%c'", *endptr);
- return (-1);
+ return -1;
} /* switch (*endptr) */
dir->size = (int64_t)temp;
- return (0);
+ return 0;
} /* int fc_config_add_dir_size */
static int fc_config_add_dir_option(fc_directory_conf_t *dir,
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) {
WARNING("filecount plugin: The `Recursive' config options needs exactly "
"one boolean argument.");
- return (-1);
+ return -1;
}
if (ci->values[0].value.boolean)
else
dir->options &= ~bit;
- return (0);
+ return 0;
} /* int fc_config_add_dir_option */
static int fc_config_add_dir(oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("filecount plugin: `Directory' needs exactly one string "
"argument.");
- return (-1);
+ return -1;
}
/* Initialize `dir' */
dir = calloc(1, sizeof(*dir));
if (dir == NULL) {
ERROR("filecount plugin: calloc failed.");
- return (-1);
+ return -1;
}
dir->path = strdup(ci->values[0].value.string);
if (dir->path == NULL) {
ERROR("filecount plugin: strdup failed.");
sfree(dir);
- return (-1);
+ return -1;
}
fc_config_set_instance(dir, dir->path);
sfree(dir->instance);
sfree(dir->path);
sfree(dir);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int fc_config_add_dir */
static int fc_config(oconfig_item_t *ci) {
}
} /* for (ci->children) */
- return (0);
+ return 0;
} /* int fc_config */
static int fc_init(void) {
if (directories_num < 1) {
WARNING("filecount plugin: No directories have been configured.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int fc_init */
static int fc_read_dir_callback(const char *dirname, const char *filename,
int status;
if (dir == NULL)
- return (-1);
+ return -1;
ssnprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, filename);
status = lstat(abs_path, &statbuf);
if (status != 0) {
ERROR("filecount plugin: stat (%s) failed.", abs_path);
- return (-1);
+ return -1;
}
if (S_ISDIR(statbuf.st_mode) && (dir->options & FC_RECURSIVE)) {
status = walk_directory(
abs_path, fc_read_dir_callback, dir,
/* include hidden = */ (dir->options & FC_HIDDEN) ? 1 : 0);
- return (status);
+ return status;
} else if (!S_ISREG(statbuf.st_mode)) {
- return (0);
+ return 0;
}
if (dir->name != NULL) {
status = fnmatch(dir->name, filename, /* flags = */ 0);
if (status != 0)
- return (0);
+ return 0;
}
if (dir->mtime != 0) {
if (((dir->mtime < 0) && (statbuf.st_mtime < mtime)) ||
((dir->mtime > 0) && (statbuf.st_mtime > mtime)))
- return (0);
+ return 0;
}
if (dir->size != 0) {
if (((dir->size < 0) && (statbuf.st_size > size)) ||
((dir->size > 0) && (statbuf.st_size < size)))
- return (0);
+ return 0;
}
dir->files_num++;
dir->files_size += (uint64_t)statbuf.st_size;
- return (0);
+ return 0;
} /* int fc_read_dir_callback */
static int fc_read_dir(fc_directory_conf_t *dir) {
/* include hidden */ (dir->options & FC_HIDDEN) ? 1 : 0);
if (status != 0) {
WARNING("filecount plugin: walk_directory (%s) failed.", dir->path);
- return (-1);
+ return -1;
}
fc_submit_dir(dir);
- return (0);
+ return 0;
} /* int fc_read_dir */
static int fc_read(void) {
for (size_t i = 0; i < directories_num; i++)
fc_read_dir(directories[i]);
- return (0);
+ return 0;
} /* int fc_read */
void module_register(void) {
diff --git a/src/fscache.c b/src/fscache.c
index 618bb22fb5eaf2c823ead3b9bbec104c42d5f82f..dd36b8b9fd128b0e16d4e4e3d52f44b8bc005cb6 100644 (file)
--- a/src/fscache.c
+++ b/src/fscache.c
} else {
printf("cant open file\n");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/gmond.c b/src/gmond.c
index 7bfb18d81762a2a00673eb47d0406b4c5788e86d..c6804276be4ca7497b88fe621e48cd08c4e12265 100644 (file)
--- a/src/gmond.c
+++ b/src/gmond.c
}
if (i >= map_len)
- return (NULL);
+ return NULL;
/* Look up the DS type and ds_index. */
if (map[i].ds_type < 0) /* {{{ */
ds = plugin_get_ds(map[i].type);
if (ds == NULL) {
WARNING("gmond plugin: Type not defined: %s", map[i].type);
- return (NULL);
+ return NULL;
}
if ((map[i].ds_name == NULL) && (ds->ds_num != 1)) {
WARNING("gmond plugin: No data source name defined for metric %s, "
"but type %s has more than one data source.",
map[i].ganglia_name, map[i].type);
- return (NULL);
+ return NULL;
}
if (map[i].ds_name == NULL) {
WARNING("gmond plugin: There is no data source "
"named `%s' in type `%s'.",
map[i].ds_name, ds->type);
- return (NULL);
+ return NULL;
}
map[i].ds_index = j;
}
map[i].ds_type = ds->ds[map[i].ds_index].type;
} /* }}} if ((map[i].ds_type < 0) || (map[i].ds_index < 0)) */
- return (map + i);
+ return map + i;
} /* }}} metric_map_t *metric_lookup */
static int create_sockets(socket_entry_t **ret_sockets, /* {{{ */
int status;
if (*ret_sockets != NULL)
- return (EINVAL);
+ return EINVAL;
struct addrinfo ai_hints = {.ai_family = AF_UNSPEC,
.ai_flags = AI_ADDRCONFIG | AI_PASSIVE,
(service == NULL) ? "(null)" : service,
(ai_return == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(ai_return));
- return (-1);
+ return -1;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
if (sockets_num == 0) {
sfree(sockets);
- return (-1);
+ return -1;
}
*ret_sockets = sockets;
*ret_sockets_num = sockets_num;
- return (0);
+ return 0;
} /* }}} int create_sockets */
static int request_meta_data(const char *host, const char *name) /* {{{ */
(msg.Ganglia_metadata_msg_u.grequest.metric_id.name == NULL)) {
sfree(msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
sfree(msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
- return (-1);
+ return -1;
}
xdrmem_create(&xdr, buffer, sizeof(buffer), XDR_ENCODE);
if (!xdr_Ganglia_metadata_msg(&xdr, &msg)) {
sfree(msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
sfree(msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
- return (-1);
+ return -1;
}
buffer_size = xdr_getpos(&xdr);
sfree(msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
sfree(msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
- return (0);
+ return 0;
} /* }}} int request_meta_data */
static staging_entry_t *staging_entry_get(const char *host, /* {{{ */
int status;
if (staging_tree == NULL)
- return (NULL);
+ return NULL;
ssnprintf(key, sizeof(key), "%s/%s/%s", host, type,
(type_instance != NULL) ? type_instance : "");
se = NULL;
status = c_avl_get(staging_tree, key, (void *)&se);
if (status == 0)
- return (se);
+ return se;
/* insert new entry */
se = calloc(1, sizeof(*se));
if (se == NULL)
- return (NULL);
+ return NULL;
sstrncpy(se->key, key, sizeof(se->key));
se->flags = 0;
se->vl.values = (value_t *)calloc(values_len, sizeof(*se->vl.values));
if (se->vl.values == NULL) {
sfree(se);
- return (NULL);
+ return NULL;
}
se->vl.values_len = values_len;
ERROR("gmond plugin: c_avl_insert failed.");
sfree(se->vl.values);
sfree(se);
- return (NULL);
+ return NULL;
}
- return (se);
+ return se;
} /* }}} staging_entry_t *staging_entry_get */
static int staging_entry_update(const char *host, const char *name, /* {{{ */
ds = plugin_get_ds(type);
if (ds == NULL) {
ERROR("gmond plugin: Looking up type %s failed.", type);
- return (-1);
+ return -1;
}
if (ds->ds_num <= ds_index) {
ERROR("gmond plugin: Invalid index %zu: %s has only %zu data source(s).",
ds_index, ds->type, ds->ds_num);
- return (-1);
+ return -1;
}
pthread_mutex_lock(&staging_lock);
if (se == NULL) {
pthread_mutex_unlock(&staging_lock);
ERROR("gmond plugin: staging_entry_get failed.");
- return (-1);
+ return -1;
}
if (se->vl.values_len != ds->ds_num) {
pthread_mutex_unlock(&staging_lock);
- return (-1);
+ return -1;
}
if (ds_type == DS_TYPE_COUNTER)
/* Check if all data sources have been set. If not, return here. */
if (se->flags != ((0x01 << se->vl.values_len) - 1)) {
pthread_mutex_unlock(&staging_lock);
- return (0);
+ return 0;
}
/* Check if the interval of this metric is known. If not, request meta data
pthread_mutex_unlock(&staging_lock);
request_meta_data(host, name);
- return (0);
+ return 0;
}
plugin_dispatch_values(&se->vl);
se->flags = 0;
pthread_mutex_unlock(&staging_lock);
- return (0);
+ return 0;
} /* }}} int staging_entry_update */
static int mc_handle_value_msg(Ganglia_value_msg *msg) /* {{{ */
}
default:
DEBUG("gmond plugin: Value type not handled: %i", msg->id);
- return (-1);
+ return -1;
} /* }}} switch (msg->id) */
assert(host != NULL);
else
assert(23 == 42);
- return (staging_entry_update(host, name, map->type, map->type_instance,
- map->ds_index, map->ds_type, val_copy));
+ return staging_entry_update(host, name, map->type, map->type_instance,
+ map->ds_index, map->ds_type, val_copy);
}
DEBUG("gmond plugin: Cannot find a translation for %s.", name);
- return (-1);
+ return -1;
} /* }}} int mc_handle_value_msg */
static int mc_handle_metadata_msg(Ganglia_metadata_msg *msg) /* {{{ */
msg_meta = msg->Ganglia_metadata_msg_u.gfull;
if (msg_meta.metric.tmax == 0)
- return (-1);
+ return -1;
map = metric_lookup(msg_meta.metric_id.name);
if (map == NULL) {
DEBUG("gmond plugin: Not handling meta data %s.",
msg_meta.metric_id.name);
- return (0);
+ return 0;
}
ds = plugin_get_ds(map->type);
if (ds == NULL) {
WARNING("gmond plugin: Could not find data set %s.", map->type);
- return (-1);
+ return -1;
}
DEBUG("gmond plugin: Received meta data for %s/%s.",
if (se == NULL) {
ERROR("gmond plugin: staging_entry_get failed.");
- return (-1);
+ return -1;
}
break;
}
- default: { return (-1); }
+ default: { return -1; }
}
- return (0);
+ return 0;
} /* }}} int mc_handle_metadata_msg */
static int mc_handle_metric(void *buffer, size_t buffer_size) /* {{{ */
default:
DEBUG("gmond plugin: Unknown format: %i", format);
- return (-1);
+ return -1;
} /* switch (format) */
- return (0);
+ return 0;
} /* }}} int mc_handle_metric */
static int mc_handle_socket(struct pollfd *p) /* {{{ */
if ((p->revents & (POLLIN | POLLPRI)) == 0) {
p->revents = 0;
- return (-1);
+ return -1;
}
buffer_size = recv(p->fd, buffer, sizeof(buffer), /* flags = */ 0);
ERROR("gmond plugin: recv failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
p->revents = 0;
- return (-1);
+ return -1;
}
mc_handle_metric(buffer, (size_t)buffer_size);
- return (0);
+ return 0;
} /* }}} int mc_handle_socket */
static void *mc_receive_thread(void *arg) /* {{{ */
/* listen = */ 1);
if (status != 0) {
ERROR("gmond plugin: create_sockets failed.");
- return ((void *)-1);
+ return (void *)-1;
}
mc_receive_sockets = (struct pollfd *)calloc(mc_receive_sockets_num,
free(mc_receive_socket_entries);
mc_receive_socket_entries = NULL;
mc_receive_sockets_num = 0;
- return ((void *)-1);
+ return (void *)-1;
}
for (size_t i = 0; i < mc_receive_sockets_num; i++) {
} /* while (mc_receive_thread_loop != 0) */
free(mc_receive_socket_entries);
- return ((void *)0);
+ return (void *)0;
} /* }}} void *mc_receive_thread */
static int mc_receive_thread_start(void) /* {{{ */
int status;
if (mc_receive_thread_running != 0)
- return (-1);
+ return -1;
mc_receive_thread_loop = 1;
if (status != 0) {
ERROR("gmond plugin: Starting receive thread failed.");
mc_receive_thread_loop = 0;
- return (-1);
+ return -1;
}
mc_receive_thread_running = 1;
- return (0);
+ return 0;
} /* }}} int start_receive_thread */
static int mc_receive_thread_stop(void) /* {{{ */
{
if (mc_receive_thread_running == 0)
- return (-1);
+ return -1;
mc_receive_thread_loop = 0;
mc_receive_thread_running = 0;
- return (0);
+ return 0;
} /* }}} int mc_receive_thread_stop */
/*
WARNING("gmond plugin: The `%s' option needs "
"exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
tmp = strdup(ci->values[0].value.string);
if (tmp == NULL) {
ERROR("gmond plugin: strdup failed.");
- return (-1);
+ return -1;
}
sfree(*str);
*str = tmp;
- return (0);
+ return 0;
} /* }}} int gmond_config_set_string */
static int gmond_config_add_metric(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("gmond plugin: `Metric' blocks need "
"exactly one string argument.");
- return (-1);
+ return -1;
}
map = realloc(metric_map, (metric_map_len + 1) * sizeof(*metric_map));
if (map == NULL) {
ERROR("gmond plugin: realloc failed.");
- return (-1);
+ return -1;
}
metric_map = map;
map = metric_map + metric_map_len;
map->ganglia_name = strdup(ci->values[0].value.string);
if (map->ganglia_name == NULL) {
ERROR("gmond plugin: strdup failed.");
- return (-1);
+ return -1;
}
for (int i = 0; i < ci->children_num; i++) {
ERROR("gmond plugin: No type is set for metric %s.", map->ganglia_name);
sfree(map->ganglia_name);
sfree(map->type_instance);
- return (-1);
+ return -1;
}
metric_map_len++;
- return (0);
+ return 0;
} /* }}} int gmond_config_add_metric */
static int gmond_config_set_address(oconfig_item_t *ci, /* {{{ */
WARNING("gmond plugin: The `%s' config option needs "
"one or two string arguments.",
ci->key);
- return (-1);
+ return -1;
}
if ((ci->values[0].type != OCONFIG_TYPE_STRING) ||
((ci->values_num == 2) && (ci->values[1].type != OCONFIG_TYPE_STRING))) {
WARNING("gmond plugin: The `%s' config option needs "
"one or two string arguments.",
ci->key);
- return (-1);
+ return -1;
}
addr = strdup(ci->values[0].value.string);
ERROR("gmond plugin: strdup failed.");
sfree(addr);
sfree(port);
- return (-1);
+ return -1;
}
sfree(*ret_addr);
*ret_addr = addr;
*ret_port = port;
- return (0);
+ return 0;
} /* }}} int gmond_config_set_address */
static int gmond_config(oconfig_item_t *ci) /* {{{ */
}
}
- return (0);
+ return 0;
} /* }}} int gmond_config */
static int gmond_init(void) /* {{{ */
staging_tree = c_avl_create((int (*)(const void *, const void *))strcmp);
if (staging_tree == NULL) {
ERROR("gmond plugin: c_avl_create failed.");
- return (-1);
+ return -1;
}
mc_receive_thread_start();
- return (0);
+ return 0;
} /* }}} int gmond_init */
static int gmond_shutdown(void) /* {{{ */
mc_send_sockets_num = 0;
pthread_mutex_unlock(&mc_send_sockets_lock);
- return (0);
+ return 0;
} /* }}} int gmond_shutdown */
void module_register(void) {
diff --git a/src/gps.c b/src/gps.c
index a4b3e2e73e0d00bca199f63b34d694cdf50ad5d1..210c29344c18e263e4ae1ddc4138f96b7d76da72 100644 (file)
--- a/src/gps.c
+++ b/src/gps.c
cgps_submit("satellites", data_copy.sats_used, "used");
cgps_submit("satellites", data_copy.sats_visible, "visible");
- return (0);
+ return 0;
}
/**
cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
}
- return (0);
+ return 0;
}
/**
plugin_thread_create(&cgps_thread_id, NULL, cgps_thread, NULL, "gps");
if (status != 0) {
ERROR("gps plugin: pthread_create() failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/**
sfree(cgps_config_data.port);
sfree(cgps_config_data.host);
- return (0);
+ return 0;
}
/**
diff --git a/src/hddtemp.c b/src/hddtemp.c
index 321c165210d4b23ac771431de18ae2c6013e6b97..3af9c0fa640433ff89cd3cc8e6cfb98e7372da5a 100644 (file)
--- a/src/hddtemp.c
+++ b/src/hddtemp.c
ERROR("hddtemp plugin: getaddrinfo (%s, %s): %s", host, port,
(ai_return == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(ai_return));
- return (NULL);
+ return NULL;
}
fd = -1;
if (fd < 0) {
ERROR("hddtemp plugin: Could not connect to daemon.");
- return (NULL);
+ return NULL;
}
/* receive data from the hddtemp daemon */
close(fd);
free(buffer);
ERROR("hddtemp plugin: Allocation failed.");
- return (NULL);
+ return NULL;
}
buffer = new_buffer;
}
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
free(buffer);
- return (NULL);
+ return NULL;
}
buffer_fill += status;
}
buffer);
close(fd);
free(buffer);
- return (NULL);
+ return NULL;
}
assert(buffer_fill < buffer_size);
buffer[buffer_fill] = '\0';
close(fd);
- return (buffer);
+ return buffer;
}
static int hddtemp_config(const char *key, const char *value) {
else
sstrncpy(hddtemp_port, value, sizeof(hddtemp_port));
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void hddtemp_submit(char *type_instance, double value) {
/* get data from daemon */
buf = hddtemp_query_daemon();
if (buf == NULL)
- return (-1);
+ return -1;
/* NB: strtok_r will eat up "||" and leading "|"'s */
ptr = buf;
}
free(buf);
- return (0);
+ return 0;
} /* int hddtemp_read */
/* module_register
diff --git a/src/hugepages.c b/src/hugepages.c
index f23a6e2a3db6ff294ecbe27ef80a2235b7429cd5..871e625f1712a78a475bc8abaab5a24d8e7702f1 100644 (file)
--- a/src/hugepages.c
+++ b/src/hugepages.c
child->key);
}
- return (0);
+ return 0;
}
static void submit_hp(const struct entry_info *info) {
diff --git a/src/intel_rdt.c b/src/intel_rdt.c
index fc2a5f1791e49775370b792fbfb3bdac9f16461c..2e0fe0fce3833e9c7d9544e4f84e7fcbbb605fd6 100644 (file)
--- a/src/intel_rdt.c
+++ b/src/intel_rdt.c
if (!(*s != '\0' && *endptr == '\0')) {
DEBUG(RDT_PLUGIN ": Error converting '%s' to unsigned number.", s);
- return (-EINVAL);
+ return -EINVAL;
}
- return (0);
+ return 0;
}
/*
*p = '\0';
ret = strtouint64(token, &start);
if (ret < 0)
- return (0);
+ return 0;
ret = strtouint64(p + 1, &end);
if (ret < 0)
- return (0);
+ return 0;
if (start > end) {
- return (0);
+ return 0;
}
for (n = start; n <= end; n++) {
if (!(isdup(nums, index, n))) {
ret = strtouint64(token, &val);
if (ret < 0)
- return (0);
+ return 0;
if (!(isdup(nums, index, val))) {
nums[index] = val;
cg->cores = calloc(num_cores, sizeof(unsigned));
if (cg->cores == NULL) {
ERROR(RDT_PLUGIN ": Error allocating core group table");
- return (-ENOMEM);
+ return -ENOMEM;
}
cg->num_cores = num_cores;
cg->desc = strdup(desc);
if (cg->desc == NULL) {
ERROR(RDT_PLUGIN ": Error allocating core group description");
sfree(cg->cores);
- return (-ENOMEM);
+ return -ENOMEM;
}
for (size_t i = 0; i < num_cores; i++)
if (n == 0) {
ERROR(RDT_PLUGIN ": Error parsing core group (%s)",
item->values[j].value.string);
- return (-EINVAL);
+ return -EINVAL;
}
/* set core group info */
if (item == NULL) {
DEBUG(RDT_PLUGIN ": cgroups_config: Invalid argument.");
- return (-EINVAL);
+ return -EINVAL;
}
DEBUG(RDT_PLUGIN ": Core groups [%d]:", item->values_num);
for (int j = 0; j < item->values_num; j++) {
if (item->values[j].type != OCONFIG_TYPE_STRING) {
ERROR(RDT_PLUGIN ": given core group value is not a string [idx=%d]", j);
- return (-EINVAL);
+ return -EINVAL;
}
DEBUG(RDT_PLUGIN ": [%d]: %s", j, item->values[j].value.string);
}
if (n < 0) {
rdt_free_cgroups();
ERROR(RDT_PLUGIN ": Error parsing core groups configuration.");
- return (-EINVAL);
+ return -EINVAL;
}
/* validate configured core id values */
g_rdt->cgroups[group_idx].desc,
(int)g_rdt->cgroups[group_idx].cores[core_idx]);
rdt_free_cgroups();
- return (-EINVAL);
+ return -EINVAL;
}
}
}
if (found != 0) {
rdt_free_cgroups();
ERROR(RDT_PLUGIN ": Cannot monitor same cores in different groups.");
- return (-EINVAL);
+ return -EINVAL;
}
}
if (g_rdt->pgroups[i] == NULL) {
rdt_free_cgroups();
ERROR(RDT_PLUGIN ": Failed to allocate memory for monitoring data.");
- return (-ENOMEM);
+ return -ENOMEM;
}
}
- return (0);
+ return 0;
}
static void rdt_pqos_log(void *context, const size_t size, const char *msg) {
if (g_rdt != NULL) {
/* already initialized if config callback was called before init callback */
- return (0);
+ return 0;
}
g_rdt = calloc(1, sizeof(*g_rdt));
if (g_rdt == NULL) {
ERROR(RDT_PLUGIN ": Failed to allocate memory for rdt context.");
- return (-ENOMEM);
+ return -ENOMEM;
}
struct pqos_config pqos = {.fd_log = -1,
/* Reset pqos monitoring groups registers */
pqos_mon_reset();
- return (0);
+ return 0;
rdt_preinit_error2:
pqos_fini();
sfree(g_rdt);
- return (-1);
+ return -1;
}
static int rdt_config(oconfig_item_t *ci) {
}
exit:
- return (0);
+ return 0;
}
static void rdt_submit_derive(char *cgroup, char *type, char *type_instance,
if (g_rdt == NULL) {
ERROR(RDT_PLUGIN ": rdt_read: plugin not initialized.");
- return (-EINVAL);
+ return -EINVAL;
}
ret = pqos_mon_poll(&g_rdt->pgroups[0], (unsigned)g_rdt->num_groups);
if (ret != PQOS_RETVAL_OK) {
ERROR(RDT_PLUGIN ": Failed to poll monitoring data.");
- return (-1);
+ return -1;
}
#if COLLECT_DEBUG
}
}
- return (0);
+ return 0;
}
static int rdt_init(void) {
int ret;
if(g_state == CONFIGURATION_ERROR)
- return (-1);
+ return -1;
ret = rdt_preinit();
if (ret != 0)
cg->desc, ret);
}
- return (0);
+ return 0;
}
static int rdt_shutdown(void) {
DEBUG(RDT_PLUGIN ": rdt_shutdown.");
if (g_rdt == NULL)
- return (0);
+ return 0;
/* Stop monitoring */
for (int i = 0; i < g_rdt->num_groups; i++) {
rdt_free_cgroups();
sfree(g_rdt);
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/interface.c b/src/interface.c
index b7c6f90e13f084d424715eb607786c05bcf4db1e..78a0d694fe18efdd0a5ac4640d157d745062abaf 100644 (file)
--- a/src/interface.c
+++ b/src/interface.c
"Solaris.");
#endif /* HAVE_LIBKSTAT */
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
#if HAVE_LIBKSTAT
numif = 0;
if (kc == NULL)
- return (-1);
+ return -1;
for (numif = 0, ksp_chain = kc->kc_chain;
(numif < MAX_NUMIF) && (ksp_chain != NULL);
ksp[numif++] = ksp_chain;
}
- return (0);
+ return 0;
} /* int interface_init */
#endif /* HAVE_LIBKSTAT */
struct IFA_DATA *if_data;
if (getifaddrs(&if_list) != 0)
- return (-1);
+ return -1;
for (struct ifaddrs *if_ptr = if_list; if_ptr != NULL;
if_ptr = if_ptr->ifa_next) {
char errbuf[1024];
WARNING("interface plugin: fopen: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, 1024, fh) != NULL) {
char iname[DATA_MAX_NAME_LEN];
if (kc == NULL)
- return (-1);
+ return -1;
for (int i = 0; i < numif; i++) {
if (kstat_read(kc, ksp[i], NULL) == -1)
char errbuf[1024];
WARNING("interface plugin: perfstat_netinterface: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (pnif != nif || ifstat == NULL) {
char errbuf[1024];
WARNING("interface plugin: perfstat_netinterface (interfaces=%d): %s", nif,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (int i = 0; i < ifs; i++) {
}
#endif /* HAVE_PERFSTAT */
- return (0);
+ return 0;
} /* int interface_read */
void module_register(void) {
diff --git a/src/ipc.c b/src/ipc.c
index 8222efbab42148c2a542aa609653bdf849e4751b..432c5e087d7e50c819b75fcb45b7955a29feaa6d 100644 (file)
--- a/src/ipc.c
+++ b/src/ipc.c
ERROR("ipc plugin: semctl(2) failed: %s. "
"Maybe the kernel is not configured for semaphores?",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
ipc_submit_g("sem", "count", "arrays", seminfo.semusz);
ipc_submit_g("sem", "count", "total", seminfo.semaem);
- return (0);
+ return 0;
} /* }}} int ipc_read_sem */
static int ipc_read_shm(void) /* {{{ */
ERROR("ipc plugin: shmctl(2) failed: %s. "
"Maybe the kernel is not configured for shared memory?",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
ipc_submit_g("shm", "segments", NULL, shm_info.used_ids);
ipc_submit_g("shm", "bytes", "total", shm_info.shm_tot * pagesize_g);
ipc_submit_g("shm", "bytes", "rss", shm_info.shm_rss * pagesize_g);
ipc_submit_g("shm", "bytes", "swapped", shm_info.shm_swp * pagesize_g);
- return (0);
+ return 0;
}
/* }}} int ipc_read_shm */
if (msgctl(0, MSG_INFO, (struct msqid_ds *)(void *)&msginfo) < 0) {
ERROR("Kernel is not configured for message queues");
- return (-1);
+ return -1;
}
ipc_submit_g("msg", "count", "queues", msginfo.msgmni);
ipc_submit_g("msg", "count", "headers", msginfo.msgmap);
ipc_submit_g("msg", "count", "space", msginfo.msgtql);
- return (0);
+ return 0;
}
/* }}} int ipc_read_msg */
static int ipc_init(void) /* {{{ */
{
pagesize_g = sysconf(_SC_PAGESIZE);
- return (0);
+ return 0;
}
/* }}} */
/* #endif KERNEL_LINUX */
char errbuf[1024];
WARNING("ipc plugin: get_ipc_info: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (NULL);
+ return NULL;
}
}
if (size % stsize) {
ERROR("ipc plugin: ipc_get_info: missmatch struct size and buffer size");
- return (NULL);
+ return NULL;
}
*nmemb = size / stsize;
buff = malloc(size);
if (buff == NULL) {
ERROR("ipc plugin: ipc_get_info malloc failed.");
- return (NULL);
+ return NULL;
}
if (get_ipc_info(cid, cmd, version, buff, &size) < 0) {
WARNING("ipc plugin: get_ipc_info: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
free(buff);
- return (NULL);
+ return NULL;
}
return buff;
ipc_submit_g("sem", "count", "arrays", sem_nsems);
ipc_submit_g("sem", "count", "total", sems);
- return (0);
+ return 0;
} /* }}} int ipc_read_sem */
static int ipc_read_shm(void) /* {{{ */
ipc_submit_g("shm", "segments", NULL, shm_segments);
ipc_submit_g("shm", "bytes", "total", shm_bytes);
- return (0);
+ return 0;
}
/* }}} int ipc_read_shm */
ipc_submit_g("msg", "count", "headers", msg_qnum);
ipc_submit_g("msg", "count", "space", msg_used_space);
- return (0);
+ return 0;
}
/* }}} */
#endif /* KERNEL_AIX */
x |= ipc_read_sem();
x |= ipc_read_msg();
- return (x);
+ return x;
}
/* }}} */
diff --git a/src/ipmi.c b/src/ipmi.c
index f3636fc8babc43860f440c9603ed160e42fb221a..98e77bfe17472a4743098b509d54b7b587e065ad 100644 (file)
--- a/src/ipmi.c
+++ b/src/ipmi.c
/* Both `ignorelist' and `plugin_instance' may be NULL. */
if (ignorelist_match(ignorelist, sensor_name_ptr) != 0)
- return (0);
+ return 0;
/* FIXME: Use rate unit or base unit to scale the value */
"because I don't know how to handle its type (%#x, %s). "
"If you need this sensor, please file a bug report.",
sensor_name_ptr, sensor_type, sensor_type_str);
- return (-1);
+ return -1;
}
} /* switch (sensor_type) */
if (list_item != NULL) {
pthread_mutex_unlock(&sensor_list_lock);
- return (0);
+ return 0;
}
list_item = (c_ipmi_sensor_list_t *)calloc(1, sizeof(c_ipmi_sensor_list_t));
if (list_item == NULL) {
pthread_mutex_unlock(&sensor_list_lock);
- return (-1);
+ return -1;
}
list_item->sensor_id = ipmi_sensor_convert_to_id(sensor);
plugin_dispatch_notification(&n);
}
- return (0);
+ return 0;
} /* int sensor_list_add */
static int sensor_list_remove(ipmi_sensor_t *sensor) {
if (list_item == NULL) {
pthread_mutex_unlock(&sensor_list_lock);
- return (-1);
+ return -1;
}
if (list_prev == NULL)
}
free(list_item);
- return (0);
+ return 0;
} /* int sensor_list_remove */
static int sensor_list_read_all(void) {
pthread_mutex_unlock(&sensor_list_lock);
- return (0);
+ return 0;
} /* int sensor_list_read_all */
static int sensor_list_remove_all(void) {
list_item = list_next;
} /* while (list_item) */
- return (0);
+ return 0;
} /* int sensor_list_remove_all */
/*
os_handler = ipmi_posix_thread_setup_os_handler(SIGIO);
if (os_handler == NULL) {
ERROR("ipmi plugin: ipmi_posix_thread_setup_os_handler failed.");
- return (-1);
+ return -1;
}
ipmi_init(os_handler);
/* user data = */ NULL, &smi_connection);
if (status != 0) {
c_ipmi_error("ipmi_smi_setup_con", status);
- return (-1);
+ return -1;
}
ipmi_open_option_t open_option[1] = {[0] = {.option = IPMI_OPEN_OPTION_ALL,
sizeof(open_option) / sizeof(open_option[0]), &domain_id);
if (status != 0) {
c_ipmi_error("ipmi_open_domain", status);
- return (-1);
+ return -1;
}
*ret_os_handler = os_handler;
- return (0);
+ return 0;
} /* int thread_init */
static void *thread_main(void __attribute__((unused)) * user_data) {
status = thread_init(&os_handler);
if (status != 0) {
ERROR("ipmi plugin: thread_init failed.\n");
- return ((void *)-1);
+ return (void *)-1;
}
while (c_ipmi_active != 0) {
ipmi_posix_thread_free_os_handler(os_handler);
- return ((void *)0);
+ return (void *)0;
} /* void *thread_main */
static int c_ipmi_config(const char *key, const char *value) {
if (ignorelist == NULL)
ignorelist = ignorelist_create(/* invert = */ 1);
if (ignorelist == NULL)
- return (1);
+ return 1;
if (strcasecmp("Sensor", key) == 0) {
ignorelist_add(ignorelist, value);
if (IS_TRUE(value))
c_ipmi_nofiy_notpresent = 1;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int c_ipmi_config */
static int c_ipmi_init(void) {
c_ipmi_active = 0;
thread_id = (pthread_t)0;
ERROR("ipmi plugin: pthread_create failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int c_ipmi_init */
static int c_ipmi_read(void) {
if ((c_ipmi_active == 0) || (thread_id == (pthread_t)0)) {
INFO("ipmi plugin: c_ipmi_read: I'm not active, returning false.");
- return (-1);
+ return -1;
}
sensor_list_read_all();
else
c_ipmi_init_in_progress = 0;
- return (0);
+ return 0;
} /* int c_ipmi_read */
static int c_ipmi_shutdown(void) {
sensor_list_remove_all();
- return (0);
+ return 0;
} /* int c_ipmi_shutdown */
void module_register(void) {
diff --git a/src/iptables.c b/src/iptables.c
index bf17cfbdd98ebc3fa30dac9b084bf64cff4cbca5..1d127bf7c6a2b55872489bcabdfaa84c79ccc535 100644 (file)
--- a/src/iptables.c
+++ b/src/iptables.c
else if (strcasecmp(key, "Chain6") == 0)
ip_version = IPV6;
else
- return (1);
+ return 1;
ip_chain_t temp = {0};
ip_chain_t * final, **list;
if (value_copy == NULL) {
char errbuf[1024];
ERROR("strdup failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
/*
fields_num = strsplit(value_copy, fields, 4);
if (fields_num < 2) {
free(value_copy);
- return (1);
+ return 1;
}
table = fields[0];
if ((unsigned int)table_len > sizeof(temp.table)) {
ERROR("Table `%s' too long.", table);
free(value_copy);
- return (1);
+ return 1;
}
sstrncpy(temp.table, table, table_len);
if ((unsigned int)chain_len > sizeof(temp.chain)) {
ERROR("Chain `%s' too long.", chain);
free(value_copy);
- return (1);
+ return 1;
}
sstrncpy(temp.chain, chain, chain_len);
temp.rule.comment = strdup(comment);
if (temp.rule.comment == NULL) {
free(value_copy);
- return (1);
+ return 1;
}
temp.rule_type = RTYPE_COMMENT;
}
char errbuf[1024];
ERROR("realloc failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
sfree(temp.rule.comment);
- return (1);
+ return 1;
}
chain_list = list;
char errbuf[1024];
ERROR("malloc failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
sfree(temp.rule.comment);
- return (1);
+ return 1;
}
memcpy(final, &temp, sizeof(temp));
chain_list[chain_num] = final;
DEBUG("Chain #%i: table = %s; chain = %s;", chain_num, final->table,
final->chain);
- return (0);
+ return 0;
} /* int iptables_config */
static int submit6_match(const struct ip6t_entry_match *match,
/* Select the rules to collect */
if (chain->rule_type == RTYPE_NUM) {
if (chain->rule.num != rule_num)
- return (0);
+ return 0;
} else {
if (strcmp(match->u.user.name, "comment") != 0)
- return (0);
+ return 0;
if ((chain->rule_type == RTYPE_COMMENT) &&
(strcmp(chain->rule.comment, (char *)match->data) != 0))
- return (0);
+ return 0;
}
sstrncpy(vl.plugin, "ip6tables", sizeof(vl.plugin));
status = ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
chain->table, chain->chain);
if ((status < 1) || ((unsigned int)status >= sizeof(vl.plugin_instance)))
- return (0);
+ return 0;
if (chain->name[0] != '\0') {
sstrncpy(vl.type_instance, chain->name, sizeof(vl.type_instance));
vl.values = &(value_t){.derive = (derive_t)entry->counters.pcnt};
plugin_dispatch_values(&vl);
- return (0);
+ return 0;
} /* int submit6_match */
/* This needs to return `int' for IPT_MATCH_ITERATE to work. */
/* Select the rules to collect */
if (chain->rule_type == RTYPE_NUM) {
if (chain->rule.num != rule_num)
- return (0);
+ return 0;
} else {
if (strcmp(match->u.user.name, "comment") != 0)
- return (0);
+ return 0;
if ((chain->rule_type == RTYPE_COMMENT) &&
(strcmp(chain->rule.comment, (char *)match->data) != 0))
- return (0);
+ return 0;
}
sstrncpy(vl.plugin, "iptables", sizeof(vl.plugin));
status = ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
chain->table, chain->chain);
if ((status < 1) || ((unsigned int)status >= sizeof(vl.plugin_instance)))
- return (0);
+ return 0;
if (chain->name[0] != '\0') {
sstrncpy(vl.type_instance, chain->name, sizeof(vl.type_instance));
vl.values = &(value_t){.derive = (derive_t)entry->counters.pcnt};
plugin_dispatch_values(&vl);
- return (0);
+ return 0;
} /* int submit_match */
/* ipv6 submit_chain */
num_failures++;
} /* for (i = 0 .. chain_num) */
- return ((num_failures < chain_num) ? 0 : -1);
+ return (num_failures < chain_num) ? 0 : -1;
} /* int iptables_read */
static int iptables_shutdown(void) {
}
sfree(chain_list);
- return (0);
+ return 0;
} /* int iptables_shutdown */
static int iptables_init(void) {
"running \"setcap cap_net_admin=ep\" on the collectd binary.");
}
#endif
- return (0);
+ return 0;
} /* int iptables_init */
void module_register(void) {
diff --git a/src/ipvs.c b/src/ipvs.c
index a8c4a1d2fe852297fcc9445db2b1dac5d3f3ca13..e614b935c542b4333bb450c586a01f8eb99c59df 100644 (file)
--- a/src/ipvs.c
+++ b/src/ipvs.c
struct ip_vs_get_services *services = NULL;
if (sockfd < 0)
- return (-1);
+ return -1;
if (NULL == (services = ipvs_get_services()))
return -1;
diff --git a/src/irq.c b/src/irq.c
index 371ba645f85779a0e8ddd951bcbf8cf30f6654ea..d54041595f1693e7409732e448a2bf1f2988374f 100644 (file)
--- a/src/irq.c
+++ b/src/irq.c
invert = 0;
ignorelist_set_invert(ignorelist, invert);
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void irq_submit(const char *irq_name, derive_t value) {
char errbuf[1024];
ERROR("irq plugin: fopen (/proc/interrupts): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* Get CPU count from the first line */
ERROR("irq plugin: unable to get CPU count from first line "
"of /proc/interrupts");
fclose(fh);
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
fclose(fh);
- return (0);
+ return 0;
} /* int irq_read */
void module_register(void) {
diff --git a/src/java.c b/src/java.c
index 2e4d88a6b64bfcbe2f54e7482e04fbe12067f094..e3d3442a5961e29dcad82075d74fae043b1b6edf 100644 (file)
--- a/src/java.c
+++ b/src/java.c
o_string = (*jvm_env)->NewStringUTF(jvm_env, (string != NULL) ? string : "");
if (o_string == NULL) {
ERROR("java plugin: ctoj_string: NewStringUTF failed.");
- return (-1);
+ return -1;
}
/* Search for the `void setFoo (String s)' method. */
ERROR("java plugin: ctoj_string: Cannot find method `void %s (String)'.",
method_name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_string);
- return (-1);
+ return -1;
}
/* Call the method. */
/* Decrease reference counter on the java.lang.String object. */
(*jvm_env)->DeleteLocalRef(jvm_env, o_string);
- return (0);
+ return 0;
} /* }}} int ctoj_string */
static jstring ctoj_output_string(JNIEnv *jvm_env, /* {{{ */
return NULL;
}
- return (o_string);
+ return o_string;
} /* }}} int ctoj_output_string */
static int ctoj_int(JNIEnv *jvm_env, /* {{{ */
if (m_set == NULL) {
ERROR("java plugin: ctoj_int: Cannot find method `void %s (int)'.",
method_name);
- return (-1);
+ return -1;
}
(*jvm_env)->CallVoidMethod(jvm_env, object_ptr, m_set, value);
- return (0);
+ return 0;
} /* }}} int ctoj_int */
static int ctoj_long(JNIEnv *jvm_env, /* {{{ */
if (m_set == NULL) {
ERROR("java plugin: ctoj_long: Cannot find method `void %s (long)'.",
method_name);
- return (-1);
+ return -1;
}
(*jvm_env)->CallVoidMethod(jvm_env, object_ptr, m_set, value);
- return (0);
+ return 0;
} /* }}} int ctoj_long */
static int ctoj_double(JNIEnv *jvm_env, /* {{{ */
if (m_set == NULL) {
ERROR("java plugin: ctoj_double: Cannot find method `void %s (double)'.",
method_name);
- return (-1);
+ return -1;
}
(*jvm_env)->CallVoidMethod(jvm_env, object_ptr, m_set, value);
- return (0);
+ return 0;
} /* }}} int ctoj_double */
/* Convert a jlong to a java.lang.Number */
if (c_long == NULL) {
ERROR("java plugin: ctoj_jlong_to_number: Looking up the "
"java.lang.Long class failed.");
- return (NULL);
+ return NULL;
}
m_long_constructor =
if (m_long_constructor == NULL) {
ERROR("java plugin: ctoj_jlong_to_number: Looking up the "
"`Long (long)' constructor failed.");
- return (NULL);
+ return NULL;
}
- return ((*jvm_env)->NewObject(jvm_env, c_long, m_long_constructor, value));
+ return (*jvm_env)->NewObject(jvm_env, c_long, m_long_constructor, value);
} /* }}} jobject ctoj_jlong_to_number */
/* Convert a jdouble to a java.lang.Number */
if (c_double == NULL) {
ERROR("java plugin: ctoj_jdouble_to_number: Looking up the "
"java.lang.Double class failed.");
- return (NULL);
+ return NULL;
}
m_double_constructor =
@@ -271,26 +271,25 @@ static jobject ctoj_jdouble_to_number(JNIEnv *jvm_env, jdouble value) /* {{{ */
if (m_double_constructor == NULL) {
ERROR("java plugin: ctoj_jdouble_to_number: Looking up the "
"`Double (double)' constructor failed.");
- return (NULL);
+ return NULL;
}
- return (
- (*jvm_env)->NewObject(jvm_env, c_double, m_double_constructor, value));
+ return (*jvm_env)->NewObject(jvm_env, c_double, m_double_constructor, value);
} /* }}} jobject ctoj_jdouble_to_number */
/* Convert a value_t to a java.lang.Number */
static jobject ctoj_value_to_number(JNIEnv *jvm_env, /* {{{ */
value_t value, int ds_type) {
if (ds_type == DS_TYPE_COUNTER)
- return (ctoj_jlong_to_number(jvm_env, (jlong)value.counter));
+ return ctoj_jlong_to_number(jvm_env, (jlong)value.counter);
else if (ds_type == DS_TYPE_GAUGE)
- return (ctoj_jdouble_to_number(jvm_env, (jdouble)value.gauge));
+ return ctoj_jdouble_to_number(jvm_env, (jdouble)value.gauge);
if (ds_type == DS_TYPE_DERIVE)
- return (ctoj_jlong_to_number(jvm_env, (jlong)value.derive));
+ return ctoj_jlong_to_number(jvm_env, (jlong)value.derive);
if (ds_type == DS_TYPE_ABSOLUTE)
- return (ctoj_jlong_to_number(jvm_env, (jlong)value.absolute));
+ return ctoj_jlong_to_number(jvm_env, (jlong)value.absolute);
else
- return (NULL);
+ return NULL;
} /* }}} jobject ctoj_value_to_number */
/* Convert a data_source_t to a org/collectd/api/DataSource */
if (c_datasource == NULL) {
ERROR("java plugin: ctoj_data_source: "
"FindClass (org/collectd/api/DataSource) failed.");
- return (NULL);
+ return NULL;
}
/* Lookup the `ValueList ()' constructor. */
if (m_datasource_constructor == NULL) {
ERROR("java plugin: ctoj_data_source: Cannot find the "
"`DataSource ()' constructor.");
- return (NULL);
+ return NULL;
}
/* Create a new instance. */
if (o_datasource == NULL) {
ERROR("java plugin: ctoj_data_source: "
"Creating a new DataSource instance failed.");
- return (NULL);
+ return NULL;
}
/* Set name via `void setName (String name)' */
ERROR("java plugin: ctoj_data_source: "
"ctoj_string (setName) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_datasource);
- return (NULL);
+ return NULL;
}
/* Set type via `void setType (int type)' */
ERROR("java plugin: ctoj_data_source: "
"ctoj_int (setType) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_datasource);
- return (NULL);
+ return NULL;
}
/* Set min via `void setMin (double min)' */
ERROR("java plugin: ctoj_data_source: "
"ctoj_double (setMin) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_datasource);
- return (NULL);
+ return NULL;
}
/* Set max via `void setMax (double max)' */
ERROR("java plugin: ctoj_data_source: "
"ctoj_double (setMax) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_datasource);
- return (NULL);
+ return NULL;
}
- return (o_datasource);
+ return o_datasource;
} /* }}} jobject ctoj_data_source */
/* Convert a oconfig_value_t to a org/collectd/api/OConfigValue */
if (c_ocvalue == NULL) {
ERROR("java plugin: ctoj_oconfig_value: "
"FindClass (org/collectd/api/OConfigValue) failed.");
- return (NULL);
+ return NULL;
}
if (ocvalue.type == OCONFIG_TYPE_BOOLEAN) {
if (m_ocvalue_constructor == NULL) {
ERROR("java plugin: ctoj_oconfig_value: Cannot find the "
"`OConfigValue (boolean)' constructor.");
- return (NULL);
+ return NULL;
}
- return ((*jvm_env)->NewObject(jvm_env, c_ocvalue, m_ocvalue_constructor,
- tmp_boolean));
+ return (*jvm_env)->NewObject(jvm_env, c_ocvalue, m_ocvalue_constructor,
+ tmp_boolean);
} /* if (ocvalue.type == OCONFIG_TYPE_BOOLEAN) */
else if (ocvalue.type == OCONFIG_TYPE_STRING) {
m_ocvalue_constructor = (*jvm_env)->GetMethodID(
if (m_ocvalue_constructor == NULL) {
ERROR("java plugin: ctoj_oconfig_value: Cannot find the "
"`OConfigValue (String)' constructor.");
- return (NULL);
+ return NULL;
}
o_argument = (*jvm_env)->NewStringUTF(jvm_env, ocvalue.value.string);
if (o_argument == NULL) {
ERROR("java plugin: ctoj_oconfig_value: "
"Creating a String object failed.");
- return (NULL);
+ return NULL;
}
} else if (ocvalue.type == OCONFIG_TYPE_NUMBER) {
m_ocvalue_constructor = (*jvm_env)->GetMethodID(
if (m_ocvalue_constructor == NULL) {
ERROR("java plugin: ctoj_oconfig_value: Cannot find the "
"`OConfigValue (Number)' constructor.");
- return (NULL);
+ return NULL;
}
o_argument = ctoj_jdouble_to_number(jvm_env, (jdouble)ocvalue.value.number);
if (o_argument == NULL) {
ERROR("java plugin: ctoj_oconfig_value: "
"Creating a Number object failed.");
- return (NULL);
+ return NULL;
}
} else {
- return (NULL);
+ return NULL;
}
assert(m_ocvalue_constructor != NULL);
ERROR("java plugin: ctoj_oconfig_value: "
"Creating an OConfigValue object failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_argument);
- return (NULL);
+ return NULL;
}
(*jvm_env)->DeleteLocalRef(jvm_env, o_argument);
- return (o_ocvalue);
+ return o_ocvalue;
} /* }}} jobject ctoj_oconfig_value */
/* Convert a oconfig_item_t to a org/collectd/api/OConfigItem */
if (c_ocitem == NULL) {
ERROR("java plugin: ctoj_oconfig_item: "
"FindClass (org/collectd/api/OConfigItem) failed.");
- return (NULL);
+ return NULL;
}
/* Get the required methods: m_ocitem_constructor, m_addvalue, and m_addchild
if (m_ocitem_constructor == NULL) {
ERROR("java plugin: ctoj_oconfig_item: Cannot find the "
"`OConfigItem (String)' constructor.");
- return (NULL);
+ return NULL;
}
m_addvalue = (*jvm_env)->GetMethodID(jvm_env, c_ocitem, "addValue",
if (m_addvalue == NULL) {
ERROR("java plugin: ctoj_oconfig_item: Cannot find the "
"`addValue (OConfigValue)' method.");
- return (NULL);
+ return NULL;
}
m_addchild = (*jvm_env)->GetMethodID(jvm_env, c_ocitem, "addChild",
if (m_addchild == NULL) {
ERROR("java plugin: ctoj_oconfig_item: Cannot find the "
"`addChild (OConfigItem)' method.");
- return (NULL);
+ return NULL;
}
/* }}} */
if (o_key == NULL) {
ERROR("java plugin: ctoj_oconfig_item: "
"Creating String object failed.");
- return (NULL);
+ return NULL;
}
/* Create an OConfigItem object */
ERROR("java plugin: ctoj_oconfig_item: "
"Creating an OConfigItem object failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_key);
- return (NULL);
+ return NULL;
}
/* We don't need the String object any longer.. */
ERROR("java plugin: ctoj_oconfig_item: "
"Creating an OConfigValue object failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_ocitem);
- return (NULL);
+ return NULL;
}
(*jvm_env)->CallVoidMethod(jvm_env, o_ocitem, m_addvalue, o_value);
ERROR("java plugin: ctoj_oconfig_item: "
"Creating an OConfigItem object failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_ocitem);
- return (NULL);
+ return NULL;
}
(*jvm_env)->CallVoidMethod(jvm_env, o_ocitem, m_addchild, o_child);
(*jvm_env)->DeleteLocalRef(jvm_env, o_child);
} /* }}} for (i = 0; i < ci->children_num; i++) */
- return (o_ocitem);
+ return o_ocitem;
} /* }}} jobject ctoj_oconfig_item */
/* Convert a data_set_t to a org/collectd/api/DataSet */
if (c_dataset == NULL) {
ERROR("java plugin: ctoj_data_set: Looking up the "
"org/collectd/api/DataSet class failed.");
- return (NULL);
+ return NULL;
}
/* Search for the `DataSet (String type)' constructor. */
if (m_constructor == NULL) {
ERROR("java plugin: ctoj_data_set: Looking up the "
"`DataSet (String)' constructor failed.");
- return (NULL);
+ return NULL;
}
/* Search for the `void addDataSource (DataSource)' method. */
if (m_add == NULL) {
ERROR("java plugin: ctoj_data_set: Looking up the "
"`addDataSource (DataSource)' method failed.");
- return (NULL);
+ return NULL;
}
o_type = (*jvm_env)->NewStringUTF(jvm_env, ds->type);
if (o_type == NULL) {
ERROR("java plugin: ctoj_data_set: Creating a String object failed.");
- return (NULL);
+ return NULL;
}
o_dataset = (*jvm_env)->NewObject(jvm_env, c_dataset, m_constructor, o_type);
if (o_dataset == NULL) {
ERROR("java plugin: ctoj_data_set: Creating a DataSet object failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_type);
- return (NULL);
+ return NULL;
}
/* Decrease reference counter on the java.lang.String object. */
ERROR("java plugin: ctoj_data_set: ctoj_data_source (%s.%s) failed",
ds->type, ds->ds[i].name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_dataset);
- return (NULL);
+ return NULL;
}
(*jvm_env)->CallVoidMethod(jvm_env, o_dataset, m_add, o_datasource);
(*jvm_env)->DeleteLocalRef(jvm_env, o_datasource);
} /* for (i = 0; i < ds->ds_num; i++) */
- return (o_dataset);
+ return o_dataset;
} /* }}} jobject ctoj_data_set */
static int ctoj_value_list_add_value(JNIEnv *jvm_env, /* {{{ */
if (m_addvalue == NULL) {
ERROR("java plugin: ctoj_value_list_add_value: "
"Cannot find method `void addValue (Number)'.");
- return (-1);
+ return -1;
}
o_number = ctoj_value_to_number(jvm_env, value, ds_type);
if (o_number == NULL) {
ERROR("java plugin: ctoj_value_list_add_value: "
"ctoj_value_to_number failed.");
- return (-1);
+ return -1;
}
(*jvm_env)->CallVoidMethod(jvm_env, object_ptr, m_addvalue, o_number);
(*jvm_env)->DeleteLocalRef(jvm_env, o_number);
- return (0);
+ return 0;
} /* }}} int ctoj_value_list_add_value */
static int ctoj_value_list_add_data_set(JNIEnv *jvm_env, /* {{{ */
if (m_setdataset == NULL) {
ERROR("java plugin: ctoj_value_list_add_data_set: "
"Cannot find the `void setDataSet (DataSet)' method.");
- return (-1);
+ return -1;
}
/* Create a DataSet object. */
ERROR("java plugin: ctoj_value_list_add_data_set: "
"ctoj_data_set (%s) failed.",
ds->type);
- return (-1);
+ return -1;
}
/* Actually call the method. */
/* Decrease reference counter on the List<DataSource> object. */
(*jvm_env)->DeleteLocalRef(jvm_env, o_dataset);
- return (0);
+ return 0;
} /* }}} int ctoj_value_list_add_data_set */
/* Convert a value_list_t (and data_set_t) to a org/collectd/api/ValueList */
if (c_valuelist == NULL) {
ERROR("java plugin: ctoj_value_list: "
"FindClass (org/collectd/api/ValueList) failed.");
- return (NULL);
+ return NULL;
}
/* Lookup the `ValueList ()' constructor. */
if (m_valuelist_constructor == NULL) {
ERROR("java plugin: ctoj_value_list: Cannot find the "
"`ValueList ()' constructor.");
- return (NULL);
+ return NULL;
}
/* Create a new instance. */
if (o_valuelist == NULL) {
ERROR("java plugin: ctoj_value_list: Creating a new ValueList instance "
"failed.");
- return (NULL);
+ return NULL;
}
status = ctoj_value_list_add_data_set(jvm_env, c_valuelist, o_valuelist, ds);
ERROR("java plugin: ctoj_value_list: "
"ctoj_value_list_add_data_set failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_valuelist);
- return (NULL);
+ return NULL;
}
/* Set the strings.. */
ERROR("java plugin: ctoj_value_list: ctoj_string (%s) failed.", \
method_name); \
(*jvm_env)->DeleteLocalRef(jvm_env, o_valuelist); \
- return (NULL); \
+ return NULL; \
} \
} while (0)
if (status != 0) {
ERROR("java plugin: ctoj_value_list: ctoj_long (setTime) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_valuelist);
- return (NULL);
+ return NULL;
}
/* Set the `interval' member.. */
if (status != 0) {
ERROR("java plugin: ctoj_value_list: ctoj_long (setInterval) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_valuelist);
- return (NULL);
+ return NULL;
}
for (size_t i = 0; i < vl->values_len; i++) {
ERROR("java plugin: ctoj_value_list: "
"ctoj_value_list_add_value failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_valuelist);
- return (NULL);
+ return NULL;
}
}
- return (o_valuelist);
+ return o_valuelist;
} /* }}} jobject ctoj_value_list */
/* Convert a notification_t to a org/collectd/api/Notification */
if (c_notification == NULL) {
ERROR("java plugin: ctoj_notification: "
"FindClass (org/collectd/api/Notification) failed.");
- return (NULL);
+ return NULL;
}
/* Lookup the `Notification ()' constructor. */
if (m_constructor == NULL) {
ERROR("java plugin: ctoj_notification: Cannot find the "
"`Notification ()' constructor.");
- return (NULL);
+ return NULL;
}
/* Create a new instance. */
if (o_notification == NULL) {
ERROR("java plugin: ctoj_notification: Creating a new Notification "
"instance failed.");
- return (NULL);
+ return NULL;
}
/* Set the strings.. */
ERROR("java plugin: ctoj_notification: ctoj_string (%s) failed.", \
method_name); \
(*jvm_env)->DeleteLocalRef(jvm_env, o_notification); \
- return (NULL); \
+ return NULL; \
} \
} while (0)
if (status != 0) {
ERROR("java plugin: ctoj_notification: ctoj_long (setTime) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_notification);
- return (NULL);
+ return NULL;
}
/* Set the `severity' member.. */
if (status != 0) {
ERROR("java plugin: ctoj_notification: ctoj_int (setSeverity) failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, o_notification);
- return (NULL);
+ return NULL;
}
- return (o_notification);
+ return o_notification;
} /* }}} jobject ctoj_notification */
/*
if (method_id == NULL) {
ERROR("java plugin: jtoc_string: Cannot find method `String %s ()'.",
method_name);
- return (-1);
+ return -1;
}
string_obj = (*jvm_env)->CallObjectMethod(jvm_env, object_ptr, method_id);
if ((string_obj == NULL) && (empty_okay == 0)) {
ERROR("java plugin: jtoc_string: CallObjectMethod (%s) failed.",
method_name);
- return (-1);
+ return -1;
} else if ((string_obj == NULL) && (empty_okay != 0)) {
memset(buffer, 0, buffer_size);
- return (0);
+ return 0;
}
c_str = (*jvm_env)->GetStringUTFChars(jvm_env, string_obj, 0);
if (c_str == NULL) {
ERROR("java plugin: jtoc_string: GetStringUTFChars failed.");
(*jvm_env)->DeleteLocalRef(jvm_env, string_obj);
- return (-1);
+ return -1;
}
sstrncpy(buffer, c_str, buffer_size);
(*jvm_env)->ReleaseStringUTFChars(jvm_env, string_obj, c_str);
(*jvm_env)->DeleteLocalRef(jvm_env, string_obj);
- return (0);
+ return 0;
} /* }}} int jtoc_string */
/* Call an `int <method> ()' method. */
if (method_id == NULL) {
ERROR("java plugin: jtoc_int: Cannot find method `int %s ()'.",
method_name);
- return (-1);
+ return -1;
}
*ret_value = (*jvm_env)->CallIntMethod(jvm_env, object_ptr, method_id);
- return (0);
+ return 0;
} /* }}} int jtoc_int */
/* Call a `long <method> ()' method. */
if (method_id == NULL) {
ERROR("java plugin: jtoc_long: Cannot find method `long %s ()'.",
method_name);
- return (-1);
+ return -1;
}
*ret_value = (*jvm_env)->CallLongMethod(jvm_env, object_ptr, method_id);
- return (0);
+ return 0;
} /* }}} int jtoc_long */
/* Call a `double <method> ()' method. */
if (method_id == NULL) {
ERROR("java plugin: jtoc_double: Cannot find method `double %s ()'.",
method_name);
- return (-1);
+ return -1;
}
*ret_value = (*jvm_env)->CallDoubleMethod(jvm_env, object_ptr, method_id);
- return (0);
+ return 0;
} /* }}} int jtoc_double */
static int jtoc_value(JNIEnv *jvm_env, /* {{{ */
if (status != 0) {
ERROR("java plugin: jtoc_value: "
"jtoc_double failed.");
- return (-1);
+ return -1;
}
(*ret_value).gauge = (gauge_t)tmp_double;
} else {
if (status != 0) {
ERROR("java plugin: jtoc_value: "
"jtoc_long failed.");
- return (-1);
+ return -1;
}
if (ds_type == DS_TYPE_DERIVE)
(*ret_value).counter = (counter_t)tmp_long;
}
- return (0);
+ return 0;
} /* }}} int jtoc_value */
/* Read a List<Number>, convert it to `value_t' and add it to the given
(*jvm_env)->DeleteLocalRef(jvm_env, o_number_array); \
if (o_list != NULL) \
(*jvm_env)->DeleteLocalRef(jvm_env, o_list); \
- return (status);
+ return status;
/* Call: List<Number> ValueList.getValues () */
m_getvalues = (*jvm_env)->GetMethodID(jvm_env, class_ptr, "getValues",
#undef BAIL_OUT
(*jvm_env)->DeleteLocalRef(jvm_env, o_number_array);
(*jvm_env)->DeleteLocalRef(jvm_env, o_list);
- return (0);
+ return 0;
} /* }}} int jtoc_values_array */
/* Convert a org/collectd/api/ValueList to a value_list_t. */
class_ptr = (*jvm_env)->GetObjectClass(jvm_env, object_ptr);
if (class_ptr == NULL) {
ERROR("java plugin: jtoc_value_list: GetObjectClass failed.");
- return (-1);
+ return -1;
}
/* eo == empty okay */
object_ptr, method); \
if (status != 0) { \
ERROR("java plugin: jtoc_value_list: jtoc_string (%s) failed.", method); \
- return (-1); \
+ return -1; \
} \
} while (0)
ERROR("java plugin: jtoc_value_list: Data-set `%s' is not defined. "
"Please consult the types.db(5) manpage for mor information.",
vl->type);
- return (-1);
+ return -1;
}
SET_STRING(vl->host, "getHost", /* empty = */ 0);
status = jtoc_long(jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
if (status != 0) {
ERROR("java plugin: jtoc_value_list: jtoc_long (getTime) failed.");
- return (-1);
+ return -1;
}
/* Java measures time in milliseconds. */
vl->time = MS_TO_CDTIME_T(tmp_long);
status = jtoc_long(jvm_env, &tmp_long, class_ptr, object_ptr, "getInterval");
if (status != 0) {
ERROR("java plugin: jtoc_value_list: jtoc_long (getInterval) failed.");
- return (-1);
+ return -1;
}
vl->interval = MS_TO_CDTIME_T(tmp_long);
status = jtoc_values_array(jvm_env, ds, vl, class_ptr, object_ptr);
if (status != 0) {
ERROR("java plugin: jtoc_value_list: jtoc_values_array failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int jtoc_value_list */
/* Convert a org/collectd/api/Notification to a notification_t. */
class_ptr = (*jvm_env)->GetObjectClass(jvm_env, object_ptr);
if (class_ptr == NULL) {
ERROR("java plugin: jtoc_notification: GetObjectClass failed.");
- return (-1);
+ return -1;
}
/* eo == empty okay */
if (status != 0) { \
ERROR("java plugin: jtoc_notification: jtoc_string (%s) failed.", \
method); \
- return (-1); \
+ return -1; \
} \
} while (0)
status = jtoc_long(jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
if (status != 0) {
ERROR("java plugin: jtoc_notification: jtoc_long (getTime) failed.");
- return (-1);
+ return -1;
}
/* Java measures time in milliseconds. */
n->time = MS_TO_CDTIME_T(tmp_long);
status = jtoc_int(jvm_env, &tmp_int, class_ptr, object_ptr, "getSeverity");
if (status != 0) {
ERROR("java plugin: jtoc_notification: jtoc_int (getSeverity) failed.");
- return (-1);
+ return -1;
}
n->severity = (int)tmp_int;
- return (0);
+ return 0;
} /* }}} int jtoc_notification */
/*
* Functions accessible from Java
status = jtoc_value_list(jvm_env, &vl, java_vl);
if (status != 0) {
ERROR("java plugin: cjni_api_dispatch_values: jtoc_value_list failed.");
- return (-1);
+ return -1;
}
status = plugin_dispatch_values(&vl);
sfree(vl.values);
- return (status);
+ return status;
} /* }}} jint cjni_api_dispatch_values */
static jint JNICALL cjni_api_dispatch_notification(JNIEnv *jvm_env, /* {{{ */
@@ -1247,12 +1246,12 @@ static jint JNICALL cjni_api_dispatch_notification(JNIEnv *jvm_env, /* {{{ */
if (status != 0) {
ERROR("java plugin: cjni_api_dispatch_notification: jtoc_notification "
"failed.");
- return (-1);
+ return -1;
}
status = plugin_dispatch_notification(&n);
- return (status);
+ return status;
} /* }}} jint cjni_api_dispatch_notification */
static jobject JNICALL cjni_api_get_ds(JNIEnv *jvm_env, /* {{{ */
ds_name = (*jvm_env)->GetStringUTFChars(jvm_env, o_string_type, 0);
if (ds_name == NULL) {
ERROR("java plugin: cjni_api_get_ds: GetStringUTFChars failed.");
- return (NULL);
+ return NULL;
}
ds = plugin_get_ds(ds_name);
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_string_type, ds_name);
if (ds == NULL)
- return (NULL);
+ return NULL;
o_dataset = ctoj_data_set(jvm_env, ds);
- return (o_dataset);
+ return o_dataset;
} /* }}} jint cjni_api_get_ds */
static jint JNICALL cjni_api_register_config(JNIEnv *jvm_env, /* {{{ */
jobject this, jobject o_name,
jobject o_config) {
- return (cjni_callback_register(jvm_env, o_name, o_config, CB_TYPE_CONFIG));
+ return cjni_callback_register(jvm_env, o_name, o_config, CB_TYPE_CONFIG);
} /* }}} jint cjni_api_register_config */
static jint JNICALL cjni_api_register_init(JNIEnv *jvm_env, /* {{{ */
jobject this, jobject o_name,
jobject o_config) {
- return (cjni_callback_register(jvm_env, o_name, o_config, CB_TYPE_INIT));
+ return cjni_callback_register(jvm_env, o_name, o_config, CB_TYPE_INIT);
} /* }}} jint cjni_api_register_init */
static jint JNICALL cjni_api_register_read(JNIEnv *jvm_env, /* {{{ */
cbi = cjni_callback_info_create(jvm_env, o_name, o_read, CB_TYPE_READ);
if (cbi == NULL)
- return (-1);
+ return -1;
DEBUG("java plugin: Registering new read callback: %s", cbi->name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_read);
- return (0);
+ return 0;
} /* }}} jint cjni_api_register_read */
static jint JNICALL cjni_api_register_write(JNIEnv *jvm_env, /* {{{ */
cbi = cjni_callback_info_create(jvm_env, o_name, o_write, CB_TYPE_WRITE);
if (cbi == NULL)
- return (-1);
+ return -1;
DEBUG("java plugin: Registering new write callback: %s", cbi->name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_write);
- return (0);
+ return 0;
} /* }}} jint cjni_api_register_write */
static jint JNICALL cjni_api_register_flush(JNIEnv *jvm_env, /* {{{ */
cbi = cjni_callback_info_create(jvm_env, o_name, o_flush, CB_TYPE_FLUSH);
if (cbi == NULL)
- return (-1);
+ return -1;
DEBUG("java plugin: Registering new flush callback: %s", cbi->name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_flush);
- return (0);
+ return 0;
} /* }}} jint cjni_api_register_flush */
static jint JNICALL cjni_api_register_shutdown(JNIEnv *jvm_env, /* {{{ */
jobject this, jobject o_name,
jobject o_shutdown) {
- return (
- cjni_callback_register(jvm_env, o_name, o_shutdown, CB_TYPE_SHUTDOWN));
+ return cjni_callback_register(jvm_env, o_name, o_shutdown, CB_TYPE_SHUTDOWN);
} /* }}} jint cjni_api_register_shutdown */
static jint JNICALL cjni_api_register_log(JNIEnv *jvm_env, /* {{{ */
cbi = cjni_callback_info_create(jvm_env, o_name, o_log, CB_TYPE_LOG);
if (cbi == NULL)
- return (-1);
+ return -1;
DEBUG("java plugin: Registering new log callback: %s", cbi->name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_log);
- return (0);
+ return 0;
} /* }}} jint cjni_api_register_log */
static jint JNICALL cjni_api_register_notification(JNIEnv *jvm_env, /* {{{ */
cbi = cjni_callback_info_create(jvm_env, o_name, o_notification,
CB_TYPE_NOTIFICATION);
if (cbi == NULL)
- return (-1);
+ return -1;
DEBUG("java plugin: Registering new notification callback: %s", cbi->name);
(*jvm_env)->DeleteLocalRef(jvm_env, o_notification);
- return (0);
+ return 0;
} /* }}} jint cjni_api_register_notification */
static jint JNICALL cjni_api_register_match_target(JNIEnv *jvm_env, /* {{{ */
@@ -1421,13 +1419,13 @@ static jint JNICALL cjni_api_register_match_target(JNIEnv *jvm_env, /* {{{ */
if (c_name == NULL) {
ERROR("java plugin: cjni_api_register_match_target: "
"GetStringUTFChars failed.");
- return (-1);
+ return -1;
}
status = cjni_callback_register(jvm_env, o_name, o_match, type);
if (status != 0) {
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
- return (-1);
+ return -1;
}
if (type == CB_TYPE_MATCH) {
ERROR("java plugin: cjni_api_register_match_target: "
"Don't know whether to create a match or a target.");
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
- return (-1);
+ return -1;
}
if (status != 0) {
@@ -1458,26 +1456,26 @@ static jint JNICALL cjni_api_register_match_target(JNIEnv *jvm_env, /* {{{ */
"%s failed.",
(type == CB_TYPE_MATCH) ? "fc_register_match" : "fc_register_target");
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
- return (-1);
+ return -1;
}
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
- return (0);
+ return 0;
} /* }}} jint cjni_api_register_match_target */
static jint JNICALL cjni_api_register_match(JNIEnv *jvm_env, /* {{{ */
jobject this, jobject o_name,
jobject o_match) {
- return (cjni_api_register_match_target(jvm_env, this, o_name, o_match,
- CB_TYPE_MATCH));
+ return cjni_api_register_match_target(jvm_env, this, o_name, o_match,
+ CB_TYPE_MATCH);
} /* }}} jint cjni_api_register_match */
static jint JNICALL cjni_api_register_target(JNIEnv *jvm_env, /* {{{ */
jobject this, jobject o_name,
jobject o_target) {
- return (cjni_api_register_match_target(jvm_env, this, o_name, o_target,
- CB_TYPE_TARGET));
+ return cjni_api_register_match_target(jvm_env, this, o_name, o_target,
+ CB_TYPE_TARGET);
} /* }}} jint cjni_api_register_target */
static void JNICALL cjni_api_log(JNIEnv *jvm_env, /* {{{ */
default:
ERROR("java plugin: cjni_callback_info_create: Unknown type: %#x", type);
- return (NULL);
+ return NULL;
}
c_name = (*jvm_env)->GetStringUTFChars(jvm_env, o_name, 0);
if (c_name == NULL) {
ERROR("java plugin: cjni_callback_info_create: "
"GetStringUTFChars failed.");
- return (NULL);
+ return NULL;
}
cbi = calloc(1, sizeof(*cbi));
if (cbi == NULL) {
ERROR("java plugin: cjni_callback_info_create: calloc failed.");
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
- return (NULL);
+ return NULL;
}
cbi->type = type;
ERROR("java plugin: cjni_callback_info_create: strdup failed.");
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
sfree(cbi);
- return (NULL);
+ return NULL;
}
(*jvm_env)->ReleaseStringUTFChars(jvm_env, o_name, c_name);
ERROR("java plugin: cjni_callback_info_create: NewGlobalRef failed.");
sfree(cbi->name);
sfree(cbi);
- return (NULL);
+ return NULL;
}
cbi->class = (*jvm_env)->GetObjectClass(jvm_env, cbi->object);
(*jvm_env)->DeleteGlobalRef(jvm_env, cbi->object);
sfree(cbi->name);
sfree(cbi);
- return (NULL);
+ return NULL;
}
cbi->method = (*jvm_env)->GetMethodID(jvm_env, cbi->class, method_name,
(*jvm_env)->DeleteGlobalRef(jvm_env, cbi->object);
sfree(cbi->name);
sfree(cbi);
- return (NULL);
+ return NULL;
}
- return (cbi);
+ return cbi;
} /* }}} cjni_callback_info_t cjni_callback_info_create */
/* Allocate a `cjni_callback_info_t' via `cjni_callback_info_create' and add it
cbi = cjni_callback_info_create(jvm_env, o_name, o_callback, type);
if (cbi == NULL)
- return (-1);
+ return -1;
#if COLLECT_DEBUG
switch (type) {
(*jvm_env)->DeleteGlobalRef(jvm_env, cbi->object);
free(cbi);
- return (-1);
+ return -1;
}
java_callbacks = tmp;
java_callbacks[java_callbacks_num] = *cbi;
pthread_mutex_unlock(&java_callbacks_lock);
free(cbi);
- return (0);
+ return 0;
} /* }}} int cjni_callback_register */
/* Callback for `pthread_key_create'. It frees the data contained in
ERROR("cjni_init_native: Cannot find the API class \"org.collectd.api"
".Collectd\". Please set the correct class path "
"using 'JVMArg \"-Djava.class.path=...\"'.");
- return (-1);
+ return -1;
}
status = (*jvm_env)->RegisterNatives(
jvm_env, api_class_ptr, jni_api_functions, (jint)jni_api_functions_num);
if (status != 0) {
ERROR("cjni_init_native: RegisterNatives failed with status %i.", status);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cjni_init_native */
/* Create the JVM. This is called when the first thread tries to access the JVM
int status;
if (jvm != NULL)
- return (0);
+ return 0;
status = pthread_key_create(&jvm_env_key, cjni_jvm_env_destroy);
if (status != 0) {
ERROR("java plugin: cjni_create_jvm: pthread_key_create failed "
"with status %i.",
status);
- return (-1);
+ return -1;
}
jvm_env = NULL;
ERROR("java plugin: cjni_create_jvm: "
"JNI_CreateJavaVM failed with status %i.",
status);
- return (-1);
+ return -1;
}
assert(jvm != NULL);
assert(jvm_env != NULL);
status = cjni_init_native(jvm_env);
if (status != 0) {
ERROR("java plugin: cjni_create_jvm: cjni_init_native failed.");
- return (-1);
+ return -1;
}
DEBUG("java plugin: The JVM has been created.");
- return (0);
+ return 0;
} /* }}} int cjni_create_jvm */
/* Increase the reference counter to the JVM for this thread. If it was zero,
status = cjni_create_jvm();
if (status != 0) {
ERROR("java plugin: cjni_thread_attach: cjni_create_jvm failed.");
- return (NULL);
+ return NULL;
}
}
assert(jvm != NULL);
cjni_env = calloc(1, sizeof(*cjni_env));
if (cjni_env == NULL) {
ERROR("java plugin: cjni_thread_attach: calloc failed.");
- return (NULL);
+ return NULL;
}
cjni_env->reference_counter = 0;
cjni_env->jvm_env = NULL;
ERROR("java plugin: cjni_thread_attach: AttachCurrentThread failed "
"with status %i.",
status);
- return (NULL);
+ return NULL;
}
cjni_env->reference_counter = 1;
DEBUG("java plugin: cjni_thread_attach: cjni_env->reference_counter = %i",
cjni_env->reference_counter);
assert(jvm_env != NULL);
- return (jvm_env);
+ return jvm_env;
} /* }}} JNIEnv *cjni_thread_attach */
/* Decrease the reference counter of this thread. If it reaches zero, detach
cjni_env = pthread_getspecific(jvm_env_key);
if (cjni_env == NULL) {
ERROR("java plugin: cjni_thread_detach: pthread_getspecific failed.");
- return (-1);
+ return -1;
}
assert(cjni_env->reference_counter > 0);
cjni_env->reference_counter);
if (cjni_env->reference_counter > 0)
- return (0);
+ return 0;
status = (*jvm)->DetachCurrentThread(jvm);
if (status != 0) {
cjni_env->reference_counter = 0;
cjni_env->jvm_env = NULL;
- return (0);
+ return 0;
} /* }}} int cjni_thread_detach */
static int cjni_config_add_jvm_arg(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("java plugin: `JVMArg' needs exactly one string argument.");
- return (-1);
+ return -1;
}
if (jvm != NULL) {
"`LoadPlugin' options! The JVM is already started and I have to "
"ignore this argument: %s",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
tmp = realloc(jvm_argv, sizeof(char *) * (jvm_argc + 1));
if (tmp == NULL) {
ERROR("java plugin: realloc failed.");
- return (-1);
+ return -1;
}
jvm_argv = tmp;
jvm_argv[jvm_argc] = strdup(ci->values[0].value.string);
if (jvm_argv[jvm_argc] == NULL) {
ERROR("java plugin: strdup failed.");
- return (-1);
+ return -1;
}
jvm_argc++;
- return (0);
+ return 0;
} /* }}} int cjni_config_add_jvm_arg */
static int cjni_config_load_plugin(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("java plugin: `LoadPlugin' needs exactly one string argument.");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
class = realloc(java_classes_list,
(java_classes_list_len + 1) * sizeof(*java_classes_list));
if (class == NULL) {
ERROR("java plugin: realloc failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
java_classes_list = class;
class = java_classes_list + java_classes_list_len;
if (class->name == NULL) {
ERROR("java plugin: strdup failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
class->class = NULL;
class->object = NULL;
class->name);
cjni_thread_detach();
free(class->name);
- return (-1);
+ return -1;
}
constructor_id =
class->name);
cjni_thread_detach();
free(class->name);
- return (-1);
+ return -1;
}
tmp_object = (*jvm_env)->NewObject(jvm_env, class->class, constructor_id);
class->name);
cjni_thread_detach();
free(class->name);
- return (-1);
+ return -1;
}
cjni_thread_detach();
java_classes_list_len++;
- return (0);
+ return 0;
} /* }}} int cjni_config_load_plugin */
static int cjni_config_plugin_block(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("java plugin: `Plugin' blocks "
"need exactly one string argument.");
- return (-1);
+ return -1;
}
name = ci->values[0].value.string;
"configuration callback has been registered. Please make sure, the "
"`LoadPlugin' lines precede the `Plugin' blocks.",
name);
- return (0);
+ return 0;
}
DEBUG("java plugin: Configuring %s", name);
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
o_ocitem = ctoj_oconfig_item(jvm_env, ci);
if (o_ocitem == NULL) {
ERROR("java plugin: cjni_config_plugin_block: ctoj_oconfig_item failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
class = (*jvm_env)->GetObjectClass(jvm_env, cbi->object);
(*jvm_env)->DeleteLocalRef(jvm_env, o_ocitem);
cjni_thread_detach();
- return (0);
+ return 0;
} /* }}} int cjni_config_plugin_block */
static int cjni_config_perform(oconfig_item_t *ci) /* {{{ */
if ((success == 0) && (errors > 0)) {
ERROR("java plugin: All statements failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cjni_config_perform */
/* Copy the children of `ci' to the global `config_block' variable. */
assert(ci != NULL);
if (ci->children_num == 0)
- return (0); /* nothing to do */
+ return 0; /* nothing to do */
ci_copy = oconfig_clone(ci);
if (ci_copy == NULL) {
ERROR("java plugin: oconfig_clone failed.");
- return (-1);
+ return -1;
}
if (config_block == NULL) {
config_block = ci_copy;
- return (0);
+ return 0;
}
tmp = realloc(config_block->children,
if (tmp == NULL) {
ERROR("java plugin: realloc failed.");
oconfig_free(ci_copy);
- return (-1);
+ return -1;
}
config_block->children = tmp;
oconfig_free(ci_copy);
- return (0);
+ return 0;
} /* }}} int cjni_config_callback */
/* Free the data contained in the `user_data_t' pointer passed to `cjni_read'
if (jvm == NULL) {
ERROR("java plugin: cjni_read: jvm == NULL");
- return (-1);
+ return -1;
}
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("java plugin: cjni_read: Invalid user data.");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
cbi = (cjni_callback_info_t *)ud->data;
ret_status = (*jvm_env)->CallIntMethod(jvm_env, cbi->object, cbi->method);
cjni_thread_detach();
- return (ret_status);
+ return ret_status;
} /* }}} int cjni_read */
/* Call the CB_TYPE_WRITE callback pointed to by the `user_data_t' pointer. */
@@ -2319,17 +2317,17 @@ static int cjni_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
if (jvm == NULL) {
ERROR("java plugin: cjni_write: jvm == NULL");
- return (-1);
+ return -1;
}
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("java plugin: cjni_write: Invalid user data.");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
cbi = (cjni_callback_info_t *)ud->data;
if (vl_java == NULL) {
ERROR("java plugin: cjni_write: ctoj_value_list failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
ret_status =
(*jvm_env)->DeleteLocalRef(jvm_env, vl_java);
cjni_thread_detach();
- return (ret_status);
+ return ret_status;
} /* }}} int cjni_write */
/* Call the CB_TYPE_FLUSH callback pointed to by the `user_data_t' pointer. */
if (jvm == NULL) {
ERROR("java plugin: cjni_flush: jvm == NULL");
- return (-1);
+ return -1;
}
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("java plugin: cjni_flush: Invalid user data.");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
cbi = (cjni_callback_info_t *)ud->data;
ERROR("java plugin: cjni_flush: Converting double "
"to Number object failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
o_identifier = NULL;
(*jvm_env)->DeleteLocalRef(jvm_env, o_timeout);
ERROR("java plugin: cjni_flush: NewStringUTF failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
}
(*jvm_env)->DeleteLocalRef(jvm_env, o_timeout);
cjni_thread_detach();
- return (ret_status);
+ return ret_status;
} /* }}} int cjni_flush */
/* Call the CB_TYPE_LOG callback pointed to by the `user_data_t' pointer. */
if (jvm == NULL) {
ERROR("java plugin: cjni_read: jvm == NULL");
- return (-1);
+ return -1;
}
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("java plugin: cjni_read: Invalid user data.");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
cbi = (cjni_callback_info_t *)ud->data;
if (o_notification == NULL) {
ERROR("java plugin: cjni_notification: ctoj_notification failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
ret_status = (*jvm_env)->CallIntMethod(jvm_env, cbi->object, cbi->method,
(*jvm_env)->DeleteLocalRef(jvm_env, o_notification);
cjni_thread_detach();
- return (ret_status);
+ return ret_status;
} /* }}} int cjni_notification */
/* Callbacks for matches implemented in Java */
if (jvm == NULL) {
ERROR("java plugin: cjni_read: jvm == NULL");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
/* Find out whether to create a match or a target. */
if (strcasecmp("Match", ci->key) == 0)
cbi_ret->name, (type == CB_TYPE_MATCH) ? "match" : "target");
/* Success! */
- return (0);
+ return 0;
#undef BAIL_OUT
} /* }}} int cjni_match_target_create */
cjni_callback_info_destroy(*user_data);
*user_data = NULL;
- return (0);
+ return 0;
} /* }}} int cjni_match_target_destroy */
static int cjni_match_target_invoke(const data_set_t *ds, /* {{{ */
if (jvm == NULL) {
ERROR("java plugin: cjni_match_target_invoke: jvm == NULL");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
cbi = (cjni_callback_info_t *)*user_data;
if (o_vl == NULL) {
ERROR("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
o_ds = ctoj_data_set(jvm_env, ds);
if (o_ds == NULL) {
ERROR("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
cjni_thread_detach();
- return (-1);
+ return -1;
}
ret_status =
} /* if (cbi->type == CB_TYPE_TARGET) */
cjni_thread_detach();
- return (ret_status);
+ return ret_status;
} /* }}} int cjni_match_target_invoke */
/* Iterate over `java_callbacks' and call all CB_TYPE_INIT callbacks. */
}
}
- return (0);
+ return 0;
} /* }}} int cjni_init_plugins */
/* Iterate over `java_callbacks' and call all CB_TYPE_SHUTDOWN callbacks. */
}
}
- return (0);
+ return 0;
} /* }}} int cjni_shutdown_plugins */
static int cjni_shutdown(void) /* {{{ */
int status;
if (jvm == NULL)
- return (0);
+ return 0;
jvm_env = NULL;
args.version = JNI_VERSION_1_2;
ERROR("java plugin: cjni_shutdown: AttachCurrentThread failed with status "
"%i.",
status);
- return (-1);
+ return -1;
}
/* Execute all the shutdown functions registered by plugins. */
jvm_argc = 0;
sfree(jvm_argv);
- return (0);
+ return 0;
} /* }}} int cjni_shutdown */
/* Initialization: Create a JVM, load all configured classes and call their
if ((config_block == NULL) && (jvm == NULL)) {
ERROR("java plugin: cjni_init: No configuration block for "
"the java plugin was found.");
- return (-1);
+ return -1;
}
if (config_block != NULL) {
if (jvm == NULL) {
ERROR("java plugin: cjni_init: jvm == NULL");
- return (-1);
+ return -1;
}
jvm_env = cjni_thread_attach();
if (jvm_env == NULL)
- return (-1);
+ return -1;
cjni_init_plugins(jvm_env);
cjni_thread_detach();
- return (0);
+ return 0;
} /* }}} int cjni_init */
void module_register(void) {
index a8f5d0d58695581528093767986ed3dc484d7242..c3cd414f202e9878d15a7768ea830c634e87b34f 100644 (file)
buf[buflen - 1] = 0;
- return (buf);
+ return buf;
} /* char *sstrerror */
static int lcc_set_errno(lcc_connection_t *c, int err) /* {{{ */
{
if (c == NULL)
- return (-1);
+ return -1;
sstrerror(err, c->errbuf, sizeof(c->errbuf));
c->errbuf[sizeof(c->errbuf) - 1] = 0;
- return (0);
+ return 0;
} /* }}} int lcc_set_errno */
static char *lcc_strescape(char *dest, const char *src,
size_t src_pos;
if ((dest == NULL) || (src == NULL))
- return (NULL);
+ return NULL;
dest_pos = 0;
src_pos = 0;
dest_pos++;
src_pos++;
- return (dest);
+ return dest;
} /* }}} char *lcc_strescape */
/* lcc_chomp: Removes all control-characters at the end of a string. */
status = fprintf(c->fh, "%s\r\n", command);
if (status < 0) {
lcc_set_errno(c, errno);
- return (-1);
+ return -1;
}
fflush(c->fh);
- return (0);
+ return 0;
} /* }}} int lcc_send */
static int lcc_receive(lcc_connection_t *c, /* {{{ */
ptr = fgets(buffer, sizeof(buffer), c->fh);
if (ptr == NULL) {
lcc_set_errno(c, errno);
- return (-1);
+ return -1;
}
lcc_chomp(buffer);
lcc_tracef("receive: <-- %s\n", buffer);
res.status = (int)strtol(buffer, &ptr, 0);
if ((errno != 0) || (ptr == &buffer[0])) {
lcc_set_errno(c, errno);
- return (-1);
+ return -1;
}
/* Skip white spaces after the status number */
/* Error or no lines follow: We're done. */
if (res.status <= 0) {
memcpy(ret_res, &res, sizeof(res));
- return (0);
+ return 0;
}
/* Allocate space for the char-pointers */
res.lines = malloc(res.lines_num * sizeof(*res.lines));
if (res.lines == NULL) {
lcc_set_errno(c, ENOMEM);
- return (-1);
+ return -1;
}
/* Now receive all the lines */
free(res.lines[i]);
}
free(res.lines);
- return (-1);
+ return -1;
}
memcpy(ret_res, &res, sizeof(res));
- return (0);
+ return 0;
} /* }}} int lcc_receive */
static int lcc_sendreceive(lcc_connection_t *c, /* {{{ */
if (c->fh == NULL) {
lcc_set_errno(c, EBADF);
- return (-1);
+ return -1;
}
status = lcc_send(c, command);
if (status != 0)
- return (status);
+ return status;
status = lcc_receive(c, &res);
if (status == 0)
memcpy(ret_res, &res, sizeof(*ret_res));
- return (status);
+ return status;
} /* }}} int lcc_sendreceive */
static int lcc_open_unixsocket(lcc_connection_t *c, const char *path) /* {{{ */
fd = socket(AF_UNIX, SOCK_STREAM, /* protocol = */ 0);
if (fd < 0) {
lcc_set_errno(c, errno);
- return (-1);
+ return -1;
}
sa.sun_family = AF_UNIX;
@@ -393,17 +393,17 @@ static int lcc_open_unixsocket(lcc_connection_t *c, const char *path) /* {{{ */
if (status != 0) {
lcc_set_errno(c, errno);
close(fd);
- return (-1);
+ return -1;
}
c->fh = fdopen(fd, "r+");
if (c->fh == NULL) {
lcc_set_errno(c, errno);
close(fd);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int lcc_open_unixsocket */
static int lcc_open_netsocket(lcc_connection_t *c, /* {{{ */
port = strchr(addr, ']');
if (port == NULL) {
LCC_SET_ERRSTR(c, "malformed address: %s", addr_orig);
- return (-1);
+ return -1;
}
*port = 0;
port++;
port = NULL;
else {
LCC_SET_ERRSTR(c, "garbage after address: %s", port);
- return (-1);
+ return -1;
}
} /* if (*addr = ']') */
else if (strchr(addr, '.') != NULL) /* Hostname or IPv4 */
&ai_res);
if (status != 0) {
LCC_SET_ERRSTR(c, "getaddrinfo: %s", gai_strerror(status));
- return (-1);
+ return -1;
}
for (struct addrinfo *ai_ptr = ai_res; ai_ptr != NULL;
if (status != 0) {
lcc_set_errno(c, status);
freeaddrinfo(ai_res);
- return (-1);
+ return -1;
}
freeaddrinfo(ai_res);
- return (0);
+ return 0;
} /* }}} int lcc_open_netsocket */
static int lcc_open_socket(lcc_connection_t *c, const char *addr) /* {{{ */
int status = 0;
if (addr == NULL)
- return (-1);
+ return -1;
assert(c != NULL);
assert(c->fh == NULL);
else
status = lcc_open_netsocket(c, addr);
- return (status);
+ return status;
} /* }}} int lcc_open_socket */
/*
*/
unsigned int lcc_version(void) /* {{{ */
{
- return (LCC_VERSION);
+ return LCC_VERSION;
} /* }}} unsigned int lcc_version */
const char *lcc_version_string(void) /* {{{ */
{
- return (LCC_VERSION_STRING);
+ return LCC_VERSION_STRING;
} /* }}} const char *lcc_version_string */
const char *lcc_version_extra(void) /* {{{ */
{
- return (LCC_VERSION_EXTRA);
+ return LCC_VERSION_EXTRA;
} /* }}} const char *lcc_version_extra */
int lcc_connect(const char *address, lcc_connection_t **ret_con) /* {{{ */
int status;
if (address == NULL)
- return (-1);
+ return -1;
if (ret_con == NULL)
- return (-1);
+ return -1;
c = calloc(1, sizeof(*c));
if (c == NULL)
- return (-1);
+ return -1;
status = lcc_open_socket(c, address);
if (status != 0) {
lcc_disconnect(c);
- return (status);
+ return status;
}
*ret_con = c;
- return (0);
+ return 0;
} /* }}} int lcc_connect */
int lcc_disconnect(lcc_connection_t *c) /* {{{ */
{
if (c == NULL)
- return (-1);
+ return -1;
if (c->fh != NULL) {
fclose(c->fh);
}
free(c);
- return (0);
+ return 0;
} /* }}} int lcc_disconnect */
int lcc_getval(lcc_connection_t *c, lcc_identifier_t *ident, /* {{{ */
int status;
if (c == NULL)
- return (-1);
+ return -1;
if (ident == NULL) {
lcc_set_errno(c, EINVAL);
- return (-1);
+ return -1;
}
/* Build a commend with an escaped version of the identifier string. */
status = lcc_identifier_to_string(c, ident_str, sizeof(ident_str), ident);
if (status != 0)
- return (status);
+ return status;
snprintf(command, sizeof(command), "GETVAL %s",
lcc_strescape(ident_esc, ident_str, sizeof(ident_esc)));
/* Send talk to the daemon.. */
status = lcc_sendreceive(c, command, &res);
if (status != 0)
- return (status);
+ return status;
if (res.status != 0) {
LCC_SET_ERRSTR(c, "Server error: %s", res.message);
lcc_response_free(&res);
- return (-1);
+ return -1;
}
values_num = res.lines_num;
} \
free(values_names); \
lcc_response_free(&res); \
- return (-1); \
+ return -1; \
} while (0)
/* If neither the values nor the names are requested, return here.. */
if (ret_values_num != NULL)
*ret_values_num = values_num;
lcc_response_free(&res);
- return (0);
+ return 0;
}
/* Allocate space for the values */
lcc_response_free(&res);
- return (0);
+ return 0;
} /* }}} int lcc_getval */
int lcc_putval(lcc_connection_t *c, const lcc_value_list_t *vl) /* {{{ */
if ((c == NULL) || (vl == NULL) || (vl->values_len < 1) ||
(vl->values == NULL) || (vl->values_types == NULL)) {
lcc_set_errno(c, EINVAL);
- return (-1);
+ return -1;
}
status = lcc_identifier_to_string(c, ident_str, sizeof(ident_str),
&vl->identifier);
if (status != 0)
- return (status);
+ return status;
SSTRCATF(command, "PUTVAL %s",
lcc_strescape(ident_esc, ident_str, sizeof(ident_esc)));
status = lcc_sendreceive(c, command, &res);
if (status != 0)
- return (status);
+ return status;
if (res.status != 0) {
LCC_SET_ERRSTR(c, "Server error: %s", res.message);
lcc_response_free(&res);
- return (-1);
+ return -1;
}
lcc_response_free(&res);
- return (0);
+ return 0;
} /* }}} int lcc_putval */
int lcc_flush(lcc_connection_t *c, const char *plugin, /* {{{ */
if (c == NULL) {
lcc_set_errno(c, EINVAL);
- return (-1);
+ return -1;
}
SSTRCPY(command, "FLUSH");
status = lcc_identifier_to_string(c, ident_str, sizeof(ident_str), ident);
if (status != 0)
- return (status);
+ return status;
SSTRCATF(command, " identifier=%s",
lcc_strescape(ident_esc, ident_str, sizeof(ident_esc)));
status = lcc_sendreceive(c, command, &res);
if (status != 0)
- return (status);
+ return status;
if (res.status != 0) {
LCC_SET_ERRSTR(c, "Server error: %s", res.message);
lcc_response_free(&res);
- return (-1);
+ return -1;
}
lcc_response_free(&res);
- return (0);
+ return 0;
} /* }}} int lcc_flush */
/* TODO: Implement lcc_putnotif */
size_t ident_num;
if (c == NULL)
- return (-1);
+ return -1;
if ((ret_ident == NULL) || (ret_ident_num == NULL)) {
lcc_set_errno(c, EINVAL);
- return (-1);
+ return -1;
}
status = lcc_sendreceive(c, "LISTVAL", &res);
if (status != 0)
- return (status);
+ return status;
if (res.status != 0) {
LCC_SET_ERRSTR(c, "Server error: %s", res.message);
lcc_response_free(&res);
- return (-1);
+ return -1;
}
ident_num = res.lines_num;
if (ident == NULL) {
lcc_response_free(&res);
lcc_set_errno(c, ENOMEM);
- return (-1);
+ return -1;
}
for (size_t i = 0; i < res.lines_num; i++) {
if (status != 0) {
free(ident);
- return (-1);
+ return -1;
}
*ret_ident = ident;
*ret_ident_num = ident_num;
- return (0);
+ return 0;
} /* }}} int lcc_listval */
const char *lcc_strerror(lcc_connection_t *c) /* {{{ */
{
if (c == NULL)
- return ("Invalid object");
- return (c->errbuf);
+ return "Invalid object";
+ return c->errbuf;
} /* }}} const char *lcc_strerror */
int lcc_identifier_to_string(lcc_connection_t *c, /* {{{ */
const lcc_identifier_t *ident) {
if ((string == NULL) || (string_size < 6) || (ident == NULL)) {
lcc_set_errno(c, EINVAL);
- return (-1);
+ return -1;
}
if (ident->plugin_instance[0] == 0) {
}
string[string_size - 1] = 0;
- return (0);
+ return 0;
} /* }}} int lcc_identifier_to_string */
int lcc_string_to_identifier(lcc_connection_t *c, /* {{{ */
string_copy = strdup(string);
if (string_copy == NULL) {
lcc_set_errno(c, ENOMEM);
- return (-1);
+ return -1;
}
host = string_copy;
if (plugin == NULL) {
LCC_SET_ERRSTR(c, "Malformed identifier string: %s", string);
free(string_copy);
- return (-1);
+ return -1;
}
*plugin = 0;
plugin++;
if (type == NULL) {
LCC_SET_ERRSTR(c, "Malformed identifier string: %s", string);
free(string_copy);
- return (-1);
+ return -1;
}
*type = 0;
type++;
SSTRCPY(ident->type_instance, type_instance);
free(string_copy);
- return (0);
+ return 0;
} /* }}} int lcc_string_to_identifier */
int lcc_identifier_compare(const void *a, /* {{{ */
int status;
if ((i0 == NULL) && (i1 == NULL))
- return (0);
+ return 0;
else if (i0 == NULL)
- return (-1);
+ return -1;
else if (i1 == NULL)
- return (1);
+ return 1;
#define CMP_FIELD(f) \
do { \
status = strcmp(i0->f, i1->f); \
if (status != 0) \
- return (status); \
+ return status; \
} while (0);
CMP_FIELD(host);
#undef CMP_FIELD
- return (0);
+ return 0;
} /* }}} int lcc_identifier_compare */
int lcc_sort_identifiers(lcc_connection_t *c, /* {{{ */
lcc_identifier_t *idents, size_t idents_num) {
if (idents == NULL) {
lcc_set_errno(c, EINVAL);
- return (-1);
+ return -1;
}
qsort(idents, idents_num, sizeof(*idents), lcc_identifier_compare);
- return (0);
+ return 0;
} /* }}} int lcc_sort_identifiers */
index d096f18699a084ee38b1e10cfefaf351a402b975..49257d4ab94830107c94bab4fc58da5451fd2ea0 100644 (file)
static int server_close_socket(lcc_server_t *srv) /* {{{ */
{
if (srv == NULL)
- return (EINVAL);
+ return EINVAL;
if (srv->fd < 0)
- return (0);
+ return 0;
close(srv->fd);
srv->fd = -1;
srv->sa = NULL;
srv->sa_len = 0;
- return (0);
+ return 0;
} /* }}} int server_close_socket */
static void int_server_destroy(lcc_server_t *srv) /* {{{ */
int status;
if (srv == NULL)
- return (EINVAL);
+ return EINVAL;
if (srv->fd >= 0)
server_close_socket(srv);
status = getaddrinfo(srv->node, srv->service, &ai_hints, &ai_list);
if (status != 0)
- return (status);
+ return status;
assert(ai_list != NULL);
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
freeaddrinfo(ai_list);
if (srv->fd < 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
} /* }}} int server_open_socket */
static int server_send_buffer(lcc_server_t *srv) /* {{{ */
if (srv->fd < 0) {
status = server_open_socket(srv);
if (status != 0)
- return (status);
+ return status;
}
buffer_size = sizeof(buffer);
status = lcc_network_buffer_finalize(srv->buffer);
if (status != 0) {
lcc_network_buffer_initialize(srv->buffer);
- return (status);
+ return status;
}
status = lcc_network_buffer_get(srv->buffer, buffer, &buffer_size);
lcc_network_buffer_initialize(srv->buffer);
if (status != 0)
- return (status);
+ return status;
if (buffer_size > sizeof(buffer))
buffer_size = sizeof(buffer);
}
if (status < 0)
- return (status);
- return (0);
+ return status;
+ return 0;
} /* }}} int server_send_buffer */
static int server_value_add(lcc_server_t *srv, /* {{{ */
status = lcc_network_buffer_add_value(srv->buffer, vl);
if (status == 0)
- return (0);
+ return 0;
server_send_buffer(srv);
- return (lcc_network_buffer_add_value(srv->buffer, vl));
+ return lcc_network_buffer_add_value(srv->buffer, vl);
} /* }}} int server_value_add */
/*
net = calloc(1, sizeof(*net));
if (net == NULL)
- return (NULL);
+ return NULL;
net->servers = NULL;
- return (net);
+ return net;
} /* }}} lcc_network_t *lcc_network_create */
void lcc_network_destroy(lcc_network_t *net) /* {{{ */
lcc_server_t *srv;
if ((net == NULL) || (node == NULL))
- return (NULL);
+ return NULL;
if (service == NULL)
service = NET_DEFAULT_PORT;
srv = calloc(1, sizeof(*srv));
if (srv == NULL)
- return (NULL);
+ return NULL;
srv->fd = -1;
srv->security_level = NONE;
srv->node = strdup(node);
if (srv->node == NULL) {
free(srv);
- return (NULL);
+ return NULL;
}
srv->service = strdup(service);
if (srv->service == NULL) {
free(srv->node);
free(srv);
- return (NULL);
+ return NULL;
}
srv->buffer = lcc_network_buffer_create(/* size = */ 0);
free(srv->service);
free(srv->node);
free(srv);
- return (NULL);
+ return NULL;
}
if (net->servers == NULL) {
last->next = srv;
}
- return (srv);
+ return srv;
} /* }}} lcc_server_t *lcc_server_create */
int lcc_server_destroy(lcc_network_t *net, lcc_server_t *srv) /* {{{ */
{
if ((net == NULL) || (srv == NULL))
- return (EINVAL);
+ return EINVAL;
if (net->servers == srv) {
net->servers = srv->next;
prev = prev->next;
if (prev == NULL)
- return (ENOENT);
+ return ENOENT;
prev->next = srv->next;
srv->next = NULL;
int_server_destroy(srv);
- return (0);
+ return 0;
} /* }}} int lcc_server_destroy */
int lcc_server_set_ttl(lcc_server_t *srv, uint8_t ttl) /* {{{ */
{
if (srv == NULL)
- return (EINVAL);
+ return EINVAL;
srv->ttl = (int)ttl;
- return (0);
+ return 0;
} /* }}} int lcc_server_set_ttl */
int lcc_server_set_interface(lcc_server_t *srv, char const *interface) /* {{{ */
@@ -370,11 +370,11 @@ int lcc_server_set_interface(lcc_server_t *srv, char const *interface) /* {{{ */
int status;
if ((srv == NULL) || (interface == NULL))
- return (EINVAL);
+ return EINVAL;
if_index = if_nametoindex(interface);
if (if_index == 0)
- return (ENOENT);
+ return ENOENT;
/* IPv4 multicast */
if (srv->sa->sa_family == AF_INET) {
@@ -398,9 +398,9 @@ int lcc_server_set_interface(lcc_server_t *srv, char const *interface) /* {{{ */
status =
setsockopt(srv->fd, IPPROTO_IP, IP_MULTICAST_IF, &mreq, sizeof(mreq));
if (status != 0)
- return (status);
+ return status;
- return (0);
+ return 0;
}
}
@@ -412,9 +412,9 @@ int lcc_server_set_interface(lcc_server_t *srv, char const *interface) /* {{{ */
status = setsockopt(srv->fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &if_index,
sizeof(if_index));
if (status != 0)
- return (status);
+ return status;
- return (0);
+ return 0;
}
}
@@ -423,26 +423,26 @@ int lcc_server_set_interface(lcc_server_t *srv, char const *interface) /* {{{ */
status = setsockopt(srv->fd, SOL_SOCKET, SO_BINDTODEVICE, interface,
(socklen_t)(strlen(interface) + 1));
if (status != 0)
- return (-1);
+ return -1;
#endif
- return (0);
+ return 0;
} /* }}} int lcc_server_set_interface */
int lcc_server_set_security_level(lcc_server_t *srv, /* {{{ */
lcc_security_level_t level,
const char *username, const char *password) {
- return (lcc_network_buffer_set_security_level(srv->buffer, level, username,
- password));
+ return lcc_network_buffer_set_security_level(srv->buffer, level, username,
+ password);
} /* }}} int lcc_server_set_security_level */
int lcc_network_values_send(lcc_network_t *net, /* {{{ */
const lcc_value_list_t *vl) {
if ((net == NULL) || (vl == NULL))
- return (EINVAL);
+ return EINVAL;
for (lcc_server_t *srv = net->servers; srv != NULL; srv = srv->next)
server_value_add(srv, vl);
- return (0);
+ return 0;
} /* }}} int lcc_network_values_send */
index 866c4cc72ae1a19866c50458558d5c42fbf548c1..662265d97996d309ef45391dab28079975d2fac6 100644 (file)
static _Bool need_init = 1;
if (!need_init)
- return (result);
+ return result;
need_init = 0;
#if HAVE_GCRYPT_H
#if GCRYPT_VERSION_NUMBER < 0x010600
if (gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread))
- return (0);
+ return 0;
#endif
if (!gcry_check_version(GCRYPT_VERSION))
- return (0);
+ return 0;
if (!gcry_control(GCRYCTL_INIT_SECMEM, 32768, 0))
- return (0);
+ return 0;
gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
result = 1;
- return (1);
+ return 1;
#else
- return (0);
+ return 0;
#endif
} /* }}} _Bool have_gcrypt */
}
if (config == 1)
- return (val);
+ return val;
hi = (uint32_t)(val >> 32);
lo = (uint32_t)(val & 0x00000000FFFFFFFF);
hi = htonl(hi);
lo = htonl(lo);
- return ((((uint64_t)lo) << 32) | ((uint64_t)hi));
+ return (((uint64_t)lo) << 32) | ((uint64_t)hi);
} /* }}} uint64_t htonll */
#endif
out.byte[4] = out.byte[5] = 0x00;
out.byte[6] = 0xf8;
out.byte[7] = 0x7f;
- return (out.floating);
+ return out.floating;
} else if (config == 1)
- return (val);
+ return val;
else if (config == 2) {
in.floating = val;
out.byte[0] = in.byte[7];
out.byte[5] = in.byte[2];
out.byte[6] = in.byte[1];
out.byte[7] = in.byte[0];
- return (out.floating);
+ return out.floating;
} else if (config == 3) {
in.floating = val;
out.byte[0] = in.byte[4];
out.byte[5] = in.byte[1];
out.byte[6] = in.byte[2];
out.byte[7] = in.byte[3];
- return (out.floating);
+ return out.floating;
} else {
/* If in doubt, just copy the value back to the caller. */
- return (val);
+ return val;
}
} /* }}} double htond */
sizeof(pkg_values_types) + sizeof(pkg_values);
if (*ret_buffer_len < packet_len)
- return (ENOMEM);
+ return ENOMEM;
pkg_type = htons(TYPE_VALUES);
pkg_length = htons((uint16_t)packet_len);
break;
default:
- return (EINVAL);
+ return EINVAL;
} /* switch (vl->values_types[i]) */
} /* for (vl->values_len) */
*ret_buffer = packet_ptr + packet_len;
*ret_buffer_len -= packet_len;
- return (0);
+ return 0;
} /* }}} int nb_add_values */
static int nb_add_number(char **ret_buffer, /* {{{ */
packet_len = sizeof(pkg_type) + sizeof(pkg_length) + sizeof(pkg_value);
if (*ret_buffer_len < packet_len)
- return (ENOMEM);
+ return ENOMEM;
pkg_type = htons(type);
pkg_length = htons((uint16_t)packet_len);
*ret_buffer = packet_ptr + packet_len;
*ret_buffer_len -= packet_len;
- return (0);
+ return 0;
} /* }}} int nb_add_number */
static int nb_add_time(char **ret_buffer, /* {{{ */
size_t *ret_buffer_len, uint16_t type, double value) {
/* Convert to collectd's "cdtime" representation. */
uint64_t cdtime_value = (uint64_t)(value * 1073741824.0);
- return (nb_add_number(ret_buffer, ret_buffer_len, type, cdtime_value));
+ return nb_add_number(ret_buffer, ret_buffer_len, type, cdtime_value);
} /* }}} int nb_add_time */
static int nb_add_string(char **ret_buffer, /* {{{ */
packet_len = sizeof(pkg_type) + sizeof(pkg_length) + str_len + 1;
if (*ret_buffer_len < packet_len)
- return (ENOMEM);
+ return ENOMEM;
pkg_type = htons(type);
pkg_length = htons((uint16_t)packet_len);
*ret_buffer = packet_ptr + packet_len;
*ret_buffer_len -= packet_len;
- return (0);
+ return 0;
} /* }}} int nb_add_string */
static int nb_add_value_list(lcc_network_buffer_t *nb, /* {{{ */
if (strcmp(ident_dst->host, ident_src->host) != 0) {
if (nb_add_string(&buffer, &buffer_size, TYPE_HOST, ident_src->host,
strlen(ident_src->host)) != 0)
- return (-1);
+ return -1;
SSTRNCPY(ident_dst->host, ident_src->host, sizeof(ident_dst->host));
}
if (strcmp(ident_dst->plugin, ident_src->plugin) != 0) {
if (nb_add_string(&buffer, &buffer_size, TYPE_PLUGIN, ident_src->plugin,
strlen(ident_src->plugin)) != 0)
- return (-1);
+ return -1;
SSTRNCPY(ident_dst->plugin, ident_src->plugin, sizeof(ident_dst->plugin));
}
if (nb_add_string(&buffer, &buffer_size, TYPE_PLUGIN_INSTANCE,
ident_src->plugin_instance,
strlen(ident_src->plugin_instance)) != 0)
- return (-1);
+ return -1;
SSTRNCPY(ident_dst->plugin_instance, ident_src->plugin_instance,
sizeof(ident_dst->plugin_instance));
}
if (strcmp(ident_dst->type, ident_src->type) != 0) {
if (nb_add_string(&buffer, &buffer_size, TYPE_TYPE, ident_src->type,
strlen(ident_src->type)) != 0)
- return (-1);
+ return -1;
SSTRNCPY(ident_dst->type, ident_src->type, sizeof(ident_dst->type));
}
if (nb_add_string(&buffer, &buffer_size, TYPE_TYPE_INSTANCE,
ident_src->type_instance,
strlen(ident_src->type_instance)) != 0)
- return (-1);
+ return -1;
SSTRNCPY(ident_dst->type_instance, ident_src->type_instance,
sizeof(ident_dst->type_instance));
}
if (nb->state.time != vl->time) {
if (nb_add_time(&buffer, &buffer_size, TYPE_TIME_HR, vl->time))
- return (-1);
+ return -1;
nb->state.time = vl->time;
}
if (nb->state.interval != vl->interval) {
if (nb_add_time(&buffer, &buffer_size, TYPE_INTERVAL_HR, vl->interval))
- return (-1);
+ return -1;
nb->state.interval = vl->interval;
}
if (nb_add_values(&buffer, &buffer_size, vl) != 0)
- return (-1);
+ return -1;
nb->ptr = buffer;
nb->free = buffer_size;
- return (0);
+ return 0;
} /* }}} int nb_add_value_list */
#if HAVE_GCRYPT_H
hd = NULL;
err = gcry_md_open(&hd, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
if (err != 0)
- return (-1);
+ return -1;
assert(nb->password != NULL);
err = gcry_md_setkey(hd, nb->password, strlen(nb->password));
if (err != 0) {
gcry_md_close(hd);
- return (-1);
+ return -1;
}
gcry_md_write(hd, buffer, buffer_size);
hash = gcry_md_read(hd, GCRY_MD_SHA256);
if (hash == NULL) {
gcry_md_close(hd);
- return (-1);
+ return -1;
}
assert(((2 * sizeof(uint16_t)) + hash_length) == PART_SIGNATURE_SHA256_SIZE);
memcpy(nb->buffer + (2 * sizeof(uint16_t)), hash, hash_length);
gcry_md_close(hd);
- return (0);
+ return 0;
} /* }}} int nb_add_signature */
static int nb_add_encryption(lcc_network_buffer_t *nb) /* {{{ */
err = gcry_cipher_open(&nb->encr_cypher, GCRY_CIPHER_AES256,
GCRY_CIPHER_MODE_OFB, /* flags = */ 0);
if (err != 0)
- return (-1);
+ return -1;
/* Calculate our 256bit key used for AES */
gcry_md_hash_buffer(GCRY_MD_SHA256, password_hash, nb->password,
if (err != 0) {
gcry_cipher_close(nb->encr_cypher);
nb->encr_cypher = NULL;
- return (-1);
+ return -1;
}
} else /* if (nb->encr_cypher != NULL) */
{
if (err != 0) {
gcry_cipher_close(nb->encr_cypher);
nb->encr_cypher = NULL;
- return (-1);
+ return -1;
}
/* Encrypt the buffer in-place */
if (err != 0) {
gcry_cipher_close(nb->encr_cypher);
nb->encr_cypher = NULL;
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int nb_add_encryption */
#endif
if (size < 128) {
errno = EINVAL;
- return (NULL);
+ return NULL;
}
nb = calloc(1, sizeof(*nb));
if (nb == NULL)
- return (NULL);
+ return NULL;
nb->size = size;
nb->buffer = calloc(1, nb->size);
if (nb->buffer == NULL) {
free(nb);
- return (NULL);
+ return NULL;
}
nb->ptr = nb->buffer;
nb->username = NULL;
nb->password = NULL;
- return (nb);
+ return nb;
} /* }}} lcc_network_buffer_t *lcc_network_buffer_create */
void lcc_network_buffer_destroy(lcc_network_buffer_t *nb) /* {{{ */
nb->password = NULL;
nb->seclevel = NONE;
lcc_network_buffer_initialize(nb);
- return (0);
+ return 0;
}
if (!have_gcrypt())
- return (ENOTSUP);
+ return ENOTSUP;
username_copy = strdup(username);
password_copy = strdup(password);
if ((username_copy == NULL) || (password_copy == NULL)) {
free(username_copy);
free(password_copy);
- return (ENOMEM);
+ return ENOMEM;
}
free(nb->username);
nb->seclevel = level;
lcc_network_buffer_initialize(nb);
- return (0);
+ return 0;
} /* }}} int lcc_network_buffer_set_security_level */
int lcc_network_buffer_initialize(lcc_network_buffer_t *nb) /* {{{ */
{
if (nb == NULL)
- return (EINVAL);
+ return EINVAL;
memset(nb->buffer, 0, nb->size);
memset(&nb->state, 0, sizeof(nb->state));
}
#endif
- return (0);
+ return 0;
} /* }}} int lcc_network_buffer_initialize */
int lcc_network_buffer_finalize(lcc_network_buffer_t *nb) /* {{{ */
{
if (nb == NULL)
- return (EINVAL);
+ return EINVAL;
#if HAVE_GCRYPT_H
if (nb->seclevel == SIGN)
return nb_add_encryption(nb);
#endif
- return (0);
+ return 0;
} /* }}} int lcc_network_buffer_finalize */
int lcc_network_buffer_add_value(lcc_network_buffer_t *nb, /* {{{ */
int status;
if ((nb == NULL) || (vl == NULL))
- return (EINVAL);
+ return EINVAL;
status = nb_add_value_list(nb, vl);
- return (status);
+ return status;
} /* }}} int lcc_network_buffer_add_value */
int lcc_network_buffer_get(lcc_network_buffer_t *nb, /* {{{ */
size_t sz_available;
if ((nb == NULL) || (buffer_size == NULL))
- return (EINVAL);
+ return EINVAL;
assert(nb->size >= nb->free);
sz_required = nb->size - nb->free;
memcpy(buffer, nb->buffer,
(sz_available < sz_required) ? sz_available : sz_required);
- return (0);
+ return 0;
} /* }}} int lcc_network_buffer_get */
index 079adcf83f3ac0568208a2fb657eef6339c72da7..0ffda3aa375d9106da2d9352a9311e74ba34c0e2 100644 (file)
--- a/src/liboconfig/oconfig.c
+++ b/src/liboconfig/oconfig.c
status = yyparse();
if (status != 0) {
fprintf(stderr, "yyparse returned error #%i\n", status);
- return (NULL);
+ return NULL;
}
c_file = NULL;
ci_root = NULL;
yyset_in((FILE *)0);
- return (ret);
+ return ret;
} /* oconfig_item_t *oconfig_parse_fh */
oconfig_item_t *oconfig_parse_file(const char *file) {
fh = fopen(file, "r");
if (fh == NULL) {
fprintf(stderr, "fopen (%s) failed: %s\n", file, strerror(errno));
- return (NULL);
+ return NULL;
}
ret = oconfig_parse_fh(fh);
c_file = NULL;
- return (ret);
+ return ret;
} /* oconfig_item_t *oconfig_parse_file */
oconfig_item_t *oconfig_clone(const oconfig_item_t *ci_orig) {
ci_copy = calloc(1, sizeof(*ci_copy));
if (ci_copy == NULL) {
fprintf(stderr, "calloc failed.\n");
- return (NULL);
+ return NULL;
}
ci_copy->values = NULL;
ci_copy->parent = NULL;
if (ci_copy->key == NULL) {
fprintf(stderr, "strdup failed.\n");
free(ci_copy);
- return (NULL);
+ return NULL;
}
if (ci_orig->values_num > 0) /* {{{ */
fprintf(stderr, "calloc failed.\n");
free(ci_copy->key);
free(ci_copy);
- return (NULL);
+ return NULL;
}
ci_copy->values_num = ci_orig->values_num;
if (ci_copy->values[i].value.string == NULL) {
fprintf(stderr, "strdup failed.\n");
oconfig_free(ci_copy);
- return (NULL);
+ return NULL;
}
} else /* ci_copy->values[i].type != OCONFIG_TYPE_STRING) */
{
if (ci_copy->children == NULL) {
fprintf(stderr, "calloc failed.\n");
oconfig_free(ci_copy);
- return (NULL);
+ return NULL;
}
ci_copy->children_num = ci_orig->children_num;
child = oconfig_clone(ci_orig->children + i);
if (child == NULL) {
oconfig_free(ci_copy);
- return (NULL);
+ return NULL;
}
child->parent = ci_copy;
ci_copy->children[i] = *child;
} /* for (i = 0; i < ci_copy->children_num; i++) */
} /* }}} if (ci_orig->children_num > 0) */
- return (ci_copy);
+ return ci_copy;
} /* oconfig_item_t *oconfig_clone */
static void oconfig_free_all(oconfig_item_t *ci) {
diff --git a/src/load.c b/src/load.c
index c7388605eb7dc0f765e2f3e4923cc012685c8aa9..d6584d502f8ca5062d53c8bf17045563fd5e32e6 100644 (file)
--- a/src/load.c
+++ b/src/load.c
"is not available, because I can't determine the "
"number of CPUS on this system. Sorry.");
#endif
- return (-1);
+ return -1;
}
static void load_submit(gauge_t snum, gauge_t mnum, gauge_t lnum) {
int cores = 0;
if ((loadavg = fopen("/proc/loadavg", "r")) == NULL) {
char errbuf[1024];
WARNING("load: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (fgets(buffer, 16, loadavg) == NULL) {
char errbuf[1024];
WARNING("load: fgets: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
fclose(loadavg);
- return (-1);
+ return -1;
}
if (fclose(loadavg)) {
numfields = strsplit(buffer, fields, 8);
if (numfields < 3)
- return (-1);
+ return -1;
snum = atof(fields[0]);
mnum = atof(fields[1]);
char errbuf[1024];
WARNING("load: perfstat_cpu : %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
snum = (float)cputotal.loadavg[0] / (float)(1 << SBITS);
#error "No applicable input method."
#endif
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/log_logstash.c b/src/log_logstash.c
index 060593047d5d447db90f1843d7aa6c2dcfffd123..28cc34c83fb17b9fc907039507033503ace055f4 100644 (file)
--- a/src/log_logstash.c
+++ b/src/log_logstash.c
if (g == NULL) {
fprintf(stderr, "Could not allocate JSON generator.\n");
- return (0);
+ return 0;
}
if (yajl_gen_map_open(g) != yajl_gen_status_ok)
}
log_logstash_print(g, LOG_INFO, (n->time != 0) ? n->time : cdtime());
- return (0);
+ return 0;
err:
yajl_gen_free(g);
fprintf(stderr, "Could not correctly generate JSON notification\n");
- return (0);
+ return 0;
} /* int log_logstash_notification */
void module_register(void) {
diff --git a/src/logfile.c b/src/logfile.c
index eca8c34758363507872f33ec13b075019c3575a0..e5807f1b4ba5ab6b9a9828cd1929b4547a41dd89 100644 (file)
--- a/src/logfile.c
+++ b/src/logfile.c
if (log_level < 0) {
log_level = LOG_INFO;
ERROR("logfile: invalid loglevel [%s] defaulting to 'info'", value);
- return (1);
+ return 1;
}
} else if (0 == strcasecmp(key, "File")) {
sfree(log_file);
logfile_print(buf, LOG_INFO, (n->time != 0) ? n->time : cdtime());
- return (0);
+ return 0;
} /* int logfile_notification */
void module_register(void) {
diff --git a/src/lpar.c b/src/lpar.c
index c01922791d01ae6000622f20ed195ddae3d6b897..a0dde32c9ace7b88141fcfe1e0db175b29173d12 100644 (file)
--- a/src/lpar.c
+++ b/src/lpar.c
else
report_by_serial = 0;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int lpar_config */
static int lpar_init(void) {
char errbuf[1024];
ERROR("lpar plugin: perfstat_partition_total failed: %s (%i)",
sstrerror(errno, errbuf, sizeof(errbuf)), status);
- return (-1);
+ return -1;
}
#if PERFSTAT_SUPPORTS_DONATION
pool_stats = 0;
}
- return (0);
+ return 0;
} /* int lpar_init */
static void lpar_submit(const char *type_instance, double value) {
from chassis to chassis through Live Partition Mobility (LPM). */
if (uname(&name) != 0) {
ERROR("lpar plugin: uname failed.");
- return (-1);
+ return -1;
}
sstrncpy(serial, name.machine, sizeof(serial));
char errbuf[1024];
ERROR("lpar plugin: perfstat_partition_total failed: %s (%i)",
sstrerror(errno, errbuf, sizeof(errbuf)), status);
- return (-1);
+ return -1;
}
/* Number of ticks since we last run. */
if (ticks == 0) {
/* The stats have not been updated. Return now to avoid
* dividing by zero */
- return (0);
+ return 0;
}
/*
memcpy(&lparstats_old, &lparstats, sizeof(lparstats_old));
- return (0);
+ return 0;
} /* int lpar_read */
void module_register(void) {
diff --git a/src/lua.c b/src/lua.c
index 9eda7d5b4ed0403bb056afb1ea542e83ce158f0d..aeaeff2465fda0134ecfddf506cdf430fbf00196 100644 (file)
--- a/src/lua.c
+++ b/src/lua.c
if (!lua_isfunction(L, -1)) {
lua_pop(L, 1);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int clua_load_callback */
/* Store the threads in a global variable so they are not cleaned up by the
lua_pushvalue(L, idx); /* +1 = 3 */
if (!lua_isthread(L, -1)) {
lua_pop(L, 3); /* -3 = 0 */
- return (-1);
+ return -1;
}
luaL_ref(L, LUA_REGISTRYINDEX);
lua_pop(L, 1); /* -1 = 0 */
- return (0);
+ return 0;
} /* }}} int clua_store_thread */
static int clua_read(user_data_t *ud) /* {{{ */
ERROR("Lua plugin: Unable to load callback \"%s\" (id %i).",
cb->lua_function_name, cb->callback_id);
pthread_mutex_unlock(&cb->lock);
- return (-1);
+ return -1;
}
/* +1 = 1 */
ERROR("Lua plugin: Calling a read callback failed: %s", errmsg);
lua_pop(L, 1);
pthread_mutex_unlock(&cb->lock);
- return (-1);
+ return -1;
}
if (!lua_isnumber(L, -1)) {
lua_pop(L, 1); /* -1 = 0 */
pthread_mutex_unlock(&cb->lock);
- return (status);
+ return status;
} /* }}} int clua_read */
static int clua_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
ERROR("Lua plugin: Unable to load callback \"%s\" (id %i).",
cb->lua_function_name, cb->callback_id);
pthread_mutex_unlock(&cb->lock);
- return (-1);
+ return -1;
}
/* +1 = 1 */
lua_pop(L, 1); /* -1 = 0 */
pthread_mutex_unlock(&cb->lock);
ERROR("Lua plugin: luaC_pushvaluelist failed.");
- return (-1);
+ return -1;
}
/* +1 = 2 */
ERROR("Lua plugin: Calling the write callback failed:\n%s", errmsg);
lua_pop(L, 1); /* -1 = 0 */
pthread_mutex_unlock(&cb->lock);
- return (-1);
+ return -1;
}
if (!lua_isnumber(L, -1)) {
lua_pop(L, 1); /* -1 = 0 */
pthread_mutex_unlock(&cb->lock);
- return (status);
+ return status;
} /* }}} int clua_write */
/*
script->lua_state = luaL_newstate();
if (script->lua_state == NULL) {
ERROR("Lua plugin: luaL_newstate() failed.");
- return (-1);
+ return -1;
}
/* Open up all the standard Lua libraries. */
lua_pop(script->lua_state, 1);
}
- return (0);
+ return 0;
} /* }}} int lua_script_init */
static int lua_script_load(const char *script_path) /* {{{ */
lua_script_t *script = malloc(sizeof(*script));
if (script == NULL) {
ERROR("Lua plugin: malloc failed.");
- return (-1);
+ return -1;
}
int status = lua_script_init(script);
if (status != 0) {
lua_script_free(script);
- return (status);
+ return status;
}
script->script_path = strdup(script_path);
if (script->script_path == NULL) {
ERROR("Lua plugin: strdup failed.");
lua_script_free(script);
- return (-1);
+ return -1;
}
status = luaL_loadfile(script->lua_state, script->script_path);
lua_tostring(script->lua_state, -1));
lua_pop(script->lua_state, 1);
lua_script_free(script);
- return (-1);
+ return -1;
}
status = lua_pcall(script->lua_state,
script->script_path, errmsg);
lua_script_free(script);
- return (-1);
+ return -1;
}
/* Append this script to the global list of scripts. */
scripts = script;
}
- return (0);
+ return 0;
} /* }}} int lua_script_load */
static int lua_config_base_path(const oconfig_item_t *ci) /* {{{ */
{
int status = cf_util_get_string_buffer(ci, base_path, sizeof(base_path));
if (status != 0)
- return (status);
+ return status;
size_t len = strlen(base_path);
while ((len > 0) && (base_path[len - 1] == '/')) {
DEBUG("Lua plugin: base_path = \"%s\";", base_path);
- return (0);
+ return 0;
} /* }}} int lua_config_base_path */
static int lua_config_script(const oconfig_item_t *ci) /* {{{ */
int status = cf_util_get_string_buffer(ci, rel_path, sizeof(rel_path));
if (status != 0)
- return (status);
+ return status;
char abs_path[PATH_MAX];
status = lua_script_load(abs_path);
if (status != 0)
- return (status);
+ return status;
INFO("Lua plugin: File \"%s\" loaded successfully", abs_path);
{
lua_script_free(scripts);
- return (0);
+ return 0;
} /* }}} int lua_shutdown */
void module_register(void) {
diff --git a/src/lvm.c b/src/lvm.c
index 3a84a6d8281e4cd1a7632324f15b313a4583fe02..c3214b07ad15c3fd315be9bbab377afb9a939a15 100644 (file)
--- a/src/lvm.c
+++ b/src/lvm.c
lvm = lvm_init(NULL);
if (!lvm) {
ERROR("lvm plugin: lvm_init failed.");
- return (-1);
+ return -1;
}
vg_names = lvm_list_vg_names(lvm);
if (!vg_names) {
ERROR("lvm plugin lvm_list_vg_name failed %s", lvm_errmsg(lvm));
lvm_quit(lvm);
- return (-1);
+ return -1;
}
dm_list_iterate_items(name_list, vg_names) {
}
lvm_quit(lvm);
- return (0);
+ return 0;
} /*lvm_read */
void module_register(void) {
diff --git a/src/madwifi.c b/src/madwifi.c
index 99e4224370a52d7e1e6d091027bae5f66b2cfe92..5a915b625e18cf3150697d068a7dd358fd945fc8 100644 (file)
--- a/src/madwifi.c
+++ b/src/madwifi.c
for (size_t i = 0; i < STATIC_ARRAY_SIZE(bounds); i++)
bounds[i]++;
- return (0);
+ return 0;
}
static int madwifi_config(const char *key, const char *value) {
int id = watchitem_find(value);
if (id < 0)
- return (-1);
+ return -1;
else
watchlist_add(watch_items, id);
}
int id = watchitem_find(value);
if (id < 0)
- return (-1);
+ return -1;
else
watchlist_remove(watch_items, id);
}
int id = watchitem_find(value);
if (id < 0)
- return (-1);
+ return -1;
else
watchlist_add(misc_items, id);
}
int id = watchitem_find(value);
if (id < 0)
- return (-1);
+ return -1;
else
watchlist_remove(misc_items, id);
}
else
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
static void submit(const char *dev, const char *type, const char *ti1,
"SIOCGATHSTATS to device %s "
"failed with status %i.",
dev, status);
- return (status);
+ return status;
}
/* These stats are handled as a special case, because they are
/* All other ath statistics */
process_stat_struct(ATH_STAT, &stats, dev, NULL, "ath_stat", "ast_misc");
- return (0);
+ return 0;
}
static int process_80211stats(int sk, const char *dev) {
"SIOCG80211STATS to device %s "
"failed with status %i.",
dev, status);
- return (status);
+ return status;
}
process_stat_struct(IFA_STAT, &stats, dev, NULL, "ath_stat", "is_misc");
- return (0);
+ return 0;
}
static int process_station(int sk, const char *dev,
"IEEE80211_IOCTL_STA_STATS to device %s "
"failed with status %i.",
dev, status);
- return (status);
+ return status;
}
/* These two stats are handled as a special case as they are
/* All other node statistics */
process_stat_struct(NOD_STAT, ns, dev, mac, "node_stat", "ns_misc");
- return (0);
+ return 0;
}
static int process_stations(int sk, const char *dev) {
"IEEE80211_IOCTL_STA_INFO to device %s "
"failed with status %i.",
dev, status);
- return (status);
+ return status;
}
len = iwr.u.data.length;
if (item_watched(STAT_ATH_NODES))
submit_gauge(dev, "ath_nodes", NULL, NULL, nodes);
- return (0);
+ return 0;
}
static int process_device(int sk, const char *dev) {
if (status == 0)
num_success++;
- return ((num_success == 0) ? -1 : 0);
+ return (num_success == 0) ? -1 : 0;
}
static int check_devname(const char *dev) {
nets = opendir("/sys/class/net/");
if (nets == NULL) {
WARNING("madwifi plugin: opening /sys/class/net failed");
- return (-1);
+ return -1;
}
num_success = 0;
closedir(nets);
if ((num_success == 0) && (num_fail != 0))
- return (-1);
- return (0);
+ return -1;
+ return 0;
}
static int procfs_iterate(int sk) {
if ((fh = fopen("/proc/net/dev", "r")) == NULL) {
WARNING("madwifi plugin: opening /proc/net/dev failed");
- return (-1);
+ return -1;
}
num_success = 0;
fclose(fh);
if ((num_success == 0) && (num_fail != 0))
- return (-1);
+ return -1;
return 0;
}
sk = socket(AF_INET, SOCK_DGRAM, 0);
if (sk < 0)
- return (-1);
+ return -1;
/* procfs iteration is not safe because it does not check whether given
interface is madwifi interface and there are private ioctls used, which
index 0b2ab1266d5062f7a0b18be3a399f06adc8a0b95..27817fe5dbde63aaadcc9e2962d00a212c4be7d7 100644 (file)
}
*user_data = NULL;
- return (0);
+ return 0;
} /* }}} int mec_create */
static int mec_destroy(__attribute__((unused)) void **user_data) /* {{{ */
{
- return (0);
+ return 0;
} /* }}} int mec_destroy */
static int mec_match(__attribute__((unused)) const data_set_t *ds, /* {{{ */
}
if ((num_counters != 0) && (num_counters == num_empty))
- return (FC_MATCH_MATCHES);
+ return FC_MATCH_MATCHES;
- return (FC_MATCH_NO_MATCH);
+ return FC_MATCH_NO_MATCH;
} /* }}} int mec_match */
void module_register(void) {
diff --git a/src/match_hashed.c b/src/match_hashed.c
index 9c8d34f922fb62d3f6ba917deb9e8a82157d701c..c0554b2339d2dfe81706c4c8a2f3e3442af38a51 100644 (file)
--- a/src/match_hashed.c
+++ b/src/match_hashed.c
(ci->values[1].type != OCONFIG_TYPE_NUMBER)) {
ERROR("hashed match: The `Match' option requires "
"exactly two numeric arguments.");
- return (-1);
+ return -1;
}
if ((ci->values[0].value.number < 0) || (ci->values[1].value.number < 0)) {
ERROR("hashed match: The arguments of the `Match' "
"option must be positive.");
- return (-1);
+ return -1;
}
tmp = realloc(m->matches, sizeof(*tmp) * (m->matches_num + 1));
if (tmp == NULL) {
ERROR("hashed match: realloc failed.");
- return (-1);
+ return -1;
}
m->matches = tmp;
tmp = m->matches + m->matches_num;
if (tmp->match >= tmp->total) {
ERROR("hashed match: The first argument of the `Match' option "
"must be smaller than the second argument.");
- return (-1);
+ return -1;
}
assert(tmp->total != 0);
m->matches_num++;
- return (0);
+ return 0;
} /* }}} int mh_config_match */
static int mh_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
m = calloc(1, sizeof(*m));
if (m == NULL) {
ERROR("mh_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
for (int i = 0; i < ci->children_num; i++) {
sfree(m->matches);
sfree(m);
ERROR("hashed match: No matches were configured. Not creating match.");
- return (-1);
+ return -1;
}
*user_data = m;
- return (0);
+ return 0;
} /* }}} int mh_create */
static int mh_destroy(void **user_data) /* {{{ */
mh_match_t *mh;
if ((user_data == NULL) || (*user_data == NULL))
- return (0);
+ return 0;
mh = *user_data;
sfree(mh->matches);
sfree(mh);
- return (0);
+ return 0;
} /* }}} int mh_destroy */
static int mh_match(const data_set_t __attribute__((unused)) * ds, /* {{{ */
uint32_t hash_val;
if ((user_data == NULL) || (*user_data == NULL))
- return (-1);
+ return -1;
m = *user_data;
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);
+ return FC_MATCH_MATCHES;
- return (FC_MATCH_NO_MATCH);
+ return FC_MATCH_NO_MATCH;
} /* }}} int mh_match */
void module_register(void) {
diff --git a/src/match_regex.c b/src/match_regex.c
index ea7fcf0134a43a4255b983a32674dd1d09261be7..6b45f6c961b7d4fae42a38ccfc624420d6b45fbc 100644 (file)
--- a/src/match_regex.c
+++ b/src/match_regex.c
static int mr_match_regexen(mr_regex_t *re_head, /* {{{ */
const char *string) {
if (re_head == NULL)
- return (FC_MATCH_MATCHES);
+ return FC_MATCH_MATCHES;
for (mr_regex_t *re = re_head; re != NULL; re = re->next) {
int status;
} else {
DEBUG("regex match: Regular expression `%s' does not match `%s'.",
re->re_str, string);
- return (FC_MATCH_NO_MATCH);
+ return FC_MATCH_NO_MATCH;
}
}
- return (FC_MATCH_MATCHES);
+ return FC_MATCH_MATCHES;
} /* }}} int mr_match_regexen */
static int mr_add_regex(mr_regex_t **re_head, const char *re_str, /* {{{ */
re = calloc(1, sizeof(*re));
if (re == NULL) {
log_err("mr_add_regex: calloc failed.");
- return (-1);
+ return -1;
}
re->next = NULL;
if (re->re_str == NULL) {
sfree(re);
log_err("mr_add_regex: strdup failed.");
- return (-1);
+ return -1;
}
status = regcomp(&re->re, re->re_str, REG_EXTENDED | REG_NOSUB);
errmsg);
sfree(re->re_str);
sfree(re);
- return (-1);
+ return -1;
}
if (*re_head == NULL) {
ptr->next = re;
}
- return (0);
+ return 0;
} /* }}} int mr_add_regex */
static int mr_config_add_regex(mr_regex_t **re_head, /* {{{ */
oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
log_warn("`%s' needs exactly one string argument.", ci->key);
- return (-1);
+ return -1;
}
return mr_add_regex(re_head, ci->values[0].value.string, ci->key);
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
log_warn("`%s' needs exactly two string arguments.", ci->key);
- return (-1);
+ return -1;
}
if (*meta == NULL) {
*meta = llist_create();
if (*meta == NULL) {
log_err("mr_config_add_meta_regex: llist_create failed.");
- return (-1);
+ return -1;
}
}
meta_key = strdup(meta_key);
if (meta_key == NULL) {
log_err("mr_config_add_meta_regex: strdup failed.");
- return (-1);
+ return -1;
}
entry = llentry_create(meta_key, NULL);
if (entry == NULL) {
log_err("mr_config_add_meta_regex: llentry_create failed.");
sfree(meta_key);
- return (-1);
+ return -1;
}
/* meta_key and entry will now be freed by mr_free_match(). */
llist_append(*meta, entry);
m = calloc(1, sizeof(*m));
if (m == NULL) {
log_err("mr_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
m->invert = 0;
if (status != 0) {
mr_free_match(m);
- return (status);
+ return status;
}
*user_data = m;
- return (0);
+ return 0;
} /* }}} int mr_create */
static int mr_destroy(void **user_data) /* {{{ */
{
if ((user_data != NULL) && (*user_data != NULL))
mr_free_match(*user_data);
- return (0);
+ return 0;
} /* }}} int mr_destroy */
static int mr_match(const data_set_t __attribute__((unused)) * ds, /* {{{ */
int nomatch_value = FC_MATCH_NO_MATCH;
if ((user_data == NULL) || (*user_data == NULL))
- return (-1);
+ return -1;
m = *user_data;
}
if (mr_match_regexen(m->host, vl->host) == FC_MATCH_NO_MATCH)
- return (nomatch_value);
+ return nomatch_value;
if (mr_match_regexen(m->plugin, vl->plugin) == FC_MATCH_NO_MATCH)
- return (nomatch_value);
+ return nomatch_value;
if (mr_match_regexen(m->plugin_instance, vl->plugin_instance) ==
FC_MATCH_NO_MATCH)
- return (nomatch_value);
+ return nomatch_value;
if (mr_match_regexen(m->type, vl->type) == FC_MATCH_NO_MATCH)
- return (nomatch_value);
+ return nomatch_value;
if (mr_match_regexen(m->type_instance, vl->type_instance) ==
FC_MATCH_NO_MATCH)
- return (nomatch_value);
+ return nomatch_value;
if (vl->meta != NULL) {
for (llentry_t *e = llist_head(m->meta); e != NULL; e = e->next) {
mr_regex_t *meta_re = (mr_regex_t *)e->value;
char *value;
int status = meta_data_get_string(vl->meta, e->key, &value);
if (status == (-ENOENT)) /* key is not present */
- return (nomatch_value);
+ return nomatch_value;
if (status != 0) /* some other problem */
continue; /* error will have already been printed. */
if (mr_match_regexen(meta_re, value) == FC_MATCH_NO_MATCH) {
sfree(value);
- return (nomatch_value);
+ return nomatch_value;
}
sfree(value);
}
}
- return (match_value);
+ return match_value;
} /* }}} int mr_match */
void module_register(void) {
diff --git a/src/match_timediff.c b/src/match_timediff.c
index f0a456b918368c1492e87721032d166cb8950c9b..c80694de39bb800c2ea257b4adc93052e7404565 100644 (file)
--- a/src/match_timediff.c
+++ b/src/match_timediff.c
m = calloc(1, sizeof(*m));
if (m == NULL) {
ERROR("mt_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
m->future = 0;
if (status != 0) {
free(m);
- return (status);
+ return status;
}
*user_data = m;
- return (0);
+ return 0;
} /* }}} int mt_create */
static int mt_destroy(void **user_data) /* {{{ */
sfree(*user_data);
}
- return (0);
+ return 0;
} /* }}} int mt_destroy */
static int mt_match(const data_set_t __attribute__((unused)) * ds, /* {{{ */
cdtime_t now;
if ((user_data == NULL) || (*user_data == NULL))
- return (-1);
+ return -1;
m = *user_data;
now = cdtime();
if (m->future != 0) {
if (vl->time >= (now + m->future))
- return (FC_MATCH_MATCHES);
+ return FC_MATCH_MATCHES;
}
if (m->past != 0) {
if (vl->time <= (now - m->past))
- return (FC_MATCH_MATCHES);
+ return FC_MATCH_MATCHES;
}
- return (FC_MATCH_NO_MATCH);
+ return FC_MATCH_NO_MATCH;
} /* }}} int mt_match */
void module_register(void) {
diff --git a/src/match_value.c b/src/match_value.c
index 45745baca677e1dd86af566e768796e20605c8d0..44cea2683290161b96e5200f98dcb06b918a308e 100644 (file)
--- a/src/match_value.c
+++ b/src/match_value.c
oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
ERROR("`value' match: `%s' needs exactly one string argument.", ci->key);
- return (-1);
+ return -1;
}
if (strcasecmp("All", ci->values[0].value.string) == 0)
ERROR("`value' match: Passing `%s' to the `%s' option is invalid. "
"The argument must either be `All' or `Any'.",
ci->values[0].value.string, ci->key);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int mv_config_add_satisfy */
static int mv_config_add_data_source(mv_match_t *m, /* {{{ */
/* Check number of arbuments. */
if (ci->values_num < 1) {
ERROR("`value' match: `%s' needs at least one argument.", ci->key);
- return (-1);
+ return -1;
}
/* Check type of arguments */
ci->key, i + 1,
(ci->values[i].type == OCONFIG_TYPE_BOOLEAN) ? "truth value"
: "number");
- return (-1);
+ return -1;
}
/* Allocate space for the char pointers */
temp = realloc(m->data_sources, new_data_sources_num * sizeof(char *));
if (temp == NULL) {
ERROR("`value' match: realloc failed.");
- return (-1);
+ return -1;
}
m->data_sources = temp;
m->data_sources_num++;
}
- return (0);
+ return 0;
} /* }}} int mv_config_add_data_source */
static int mv_config_add_gauge(gauge_t *ret_value, /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) {
ERROR("`value' match: `%s' needs exactly one numeric argument.", ci->key);
- return (-1);
+ return -1;
}
*ret_value = ci->values[0].value.number;
- return (0);
+ return 0;
} /* }}} int mv_config_add_gauge */
static int mv_config_add_boolean(int *ret_value, /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) {
ERROR("`value' match: `%s' needs exactly one boolean argument.", ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].value.boolean)
else
*ret_value = 0;
- return (0);
+ return 0;
} /* }}} int mv_config_add_boolean */
static int mv_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
m = calloc(1, sizeof(*m));
if (m == NULL) {
ERROR("mv_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
m->min = NAN;
if (status != 0) {
mv_free_match(m);
- return (status);
+ return status;
}
*user_data = m;
- return (0);
+ return 0;
} /* }}} int mv_create */
static int mv_destroy(void **user_data) /* {{{ */
{
if ((user_data != NULL) && (*user_data != NULL))
mv_free_match(*user_data);
- return (0);
+ return 0;
} /* }}} int mv_destroy */
static int mv_match(const data_set_t *ds, const value_list_t *vl, /* {{{ */
int status;
if ((user_data == NULL) || (*user_data == NULL))
- return (-1);
+ return -1;
m = *user_data;
if (values == NULL) {
ERROR("`value' match: Retrieving the current rate from the cache "
"failed.");
- return (-1);
+ return -1;
}
status = FC_MATCH_NO_MATCH;
} /* for (i = 0; i < ds->ds_num; i++) */
free(values);
- return (status);
+ return status;
} /* }}} int mv_match */
void module_register(void) {
diff --git a/src/mbmon.c b/src/mbmon.c
index aa593a03db4989fa73ed29f4430960db5e47374e..b5352bf6e5d8f4e9c9f8d295eb037e53475075e5 100644 (file)
--- a/src/mbmon.c
+++ b/src/mbmon.c
ERROR("mbmon: getaddrinfo (%s, %s): %s", host, port,
(ai_return == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(ai_return));
- return (-1);
+ return -1;
}
fd = -1;
if (fd < 0) {
ERROR("mbmon: Could not connect to daemon.");
- return (-1);
+ return -1;
}
/* receive data from the mbmon daemon */
ERROR("mbmon: Error reading from socket: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
- return (-1);
+ return -1;
}
buffer_fill += status;
"Buffer: `%s'",
buffer);
close(fd);
- return (-1);
+ return -1;
}
close(fd);
- return (0);
+ return 0;
}
static int mbmon_config(const char *key, const char *value) {
free(mbmon_port);
mbmon_port = strdup(value);
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void mbmon_submit(const char *type, const char *type_instance,
/* get data from daemon */
if (mbmon_query_daemon(buf, sizeof(buf)) < 0)
- return (-1);
+ return -1;
s = buf;
while ((t = strchr(s, ':')) != NULL) {
s = nextc + 1;
}
- return (0);
+ return 0;
} /* void mbmon_read */
/* module_register
diff --git a/src/mcelog.c b/src/mcelog.c
index 4e6a6fd1deda8ab070f64039269b58bbee574e99..fad18d50e4c554f974546ca4d769aef36e653d3f 100644 (file)
--- a/src/mcelog.c
+++ b/src/mcelog.c
0) {
ERROR(MCELOG_PLUGIN ": Invalid configuration option: \"%s\".",
child->key);
- return (-1);
+ return -1;
}
} else if (strcasecmp("McelogLogfile", child->key) == 0) {
if (cf_util_get_string_buffer(child, g_mcelog_config.logfile,
sizeof(g_mcelog_config.logfile)) < 0) {
ERROR(MCELOG_PLUGIN ": Invalid configuration option: \"%s\".",
child->key);
- return (-1);
+ return -1;
}
} else {
ERROR(MCELOG_PLUGIN ": Invalid configuration option: \"%s\".",
child->key);
- return (-1);
+ return -1;
}
}
- return (0);
+ return 0;
}
static int socket_close(socket_adapter_t *self) {
}
}
pthread_rwlock_unlock(&self->lock);
- return (ret);
+ return ret;
}
static int socket_write(socket_adapter_t *self, const char *msg,
if (swrite(self->sock_fd, msg, len) < 0)
ret = -1;
pthread_rwlock_unlock(&self->lock);
- return (ret);
+ return ret;
}
static void mcelog_dispatch_notification(notification_t *n) {
ERROR(MCELOG_PLUGIN ": Could not create a socket. %s",
sstrerror(errno, errbuff, sizeof(errbuff)));
pthread_rwlock_unlock(&self->lock);
- return (ret);
+ return ret;
}
/* Set socket timeout option */
.type_instance = "mcelog_status"});
}
pthread_rwlock_unlock(&self->lock);
- return (ret);
+ return ret;
}
static int mcelog_prepare_notification(notification_t *n,
const mcelog_memory_rec_t *mr) {
if (n == NULL || mr == NULL)
- return (-1);
+ return -1;
if ((mr->location[0] != '\0') &&
(plugin_notification_meta_add_string(n, MCELOG_SOCKET_STR, mr->location) <
0)) {
ERROR(MCELOG_PLUGIN ": add memory location meta data failed");
- return (-1);
+ return -1;
}
if ((mr->dimm_name[0] != '\0') &&
(plugin_notification_meta_add_string(n, MCELOG_DIMM_NAME, mr->dimm_name) <
0)) {
ERROR(MCELOG_PLUGIN ": add DIMM name meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
if (plugin_notification_meta_add_signed_int(n, MCELOG_CORRECTED_ERR,
mr->corrected_err_total) < 0) {
ERROR(MCELOG_PLUGIN ": add corrected errors meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
if (plugin_notification_meta_add_signed_int(
n, "corrected memory timed errors", mr->corrected_err_timed) < 0) {
ERROR(MCELOG_PLUGIN ": add corrected timed errors meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
if ((mr->corrected_err_timed_period[0] != '\0') &&
(plugin_notification_meta_add_string(n, "corrected errors time period",
0)) {
ERROR(MCELOG_PLUGIN ": add corrected errors period meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
if (plugin_notification_meta_add_signed_int(n, MCELOG_UNCORRECTED_ERR,
mr->uncorrected_err_total) < 0) {
ERROR(MCELOG_PLUGIN ": add corrected errors meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
if (plugin_notification_meta_add_signed_int(n,
"uncorrected memory timed errors",
mr->uncorrected_err_timed) < 0) {
ERROR(MCELOG_PLUGIN ": add corrected timed errors meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
if ((mr->uncorrected_err_timed_period[0] != '\0') &&
(plugin_notification_meta_add_string(n, "uncorrected errors time period",
0)) {
ERROR(MCELOG_PLUGIN ": add corrected errors period meta data failed");
plugin_notification_meta_free(n->meta);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static int mcelog_submit(const mcelog_memory_rec_t *mr) {
if (!mr) {
ERROR(MCELOG_PLUGIN ": %s: NULL pointer", __FUNCTION__);
- return (-1);
+ return -1;
}
value_list_t vl = {
vl.values = &(value_t){.derive = (derive_t)mr->uncorrected_err_timed};
plugin_dispatch_values(&vl);
- return (0);
+ return 0;
}
static int parse_memory_info(FILE *p_file, mcelog_memory_rec_t *memory_record) {
@@ -323,7 +323,7 @@ static int parse_memory_info(FILE *p_file, mcelog_memory_rec_t *memory_record) {
/* Got empty line or "done" */
if ((!strncmp("\n", buf, strlen(buf))) ||
(!strncmp(buf, "done\n", strlen(buf))))
- return (1);
+ return 1;
if (strlen(buf) < 5)
continue;
if (!strncmp(buf, MCELOG_SOCKET_STR, strlen(MCELOG_SOCKET_STR))) {
@@ -379,7 +379,7 @@ static int parse_memory_info(FILE *p_file, mcelog_memory_rec_t *memory_record) {
memset(buf, 0, sizeof(buf));
}
/* parsing definitely finished */
- return (0);
+ return 0;
}
static void poll_worker_cleanup(void *arg) {
sstrerror(errno, errbuf, sizeof(errbuf)));
}
pthread_rwlock_unlock(&self->lock);
- return (res);
+ return res;
}
if (poll_fd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
.type_instance = "mcelog_status"});
}
pthread_rwlock_unlock(&self->lock);
- return (-1);
+ return -1;
}
if (!(poll_fd.revents & (POLLIN | POLLPRI))) {
INFO(MCELOG_PLUGIN ": No data to read");
pthread_rwlock_unlock(&self->lock);
- return (0);
+ return 0;
}
if ((*pp_file = fdopen(dup(self->sock_fd), "r")) == NULL)
res = -1;
pthread_rwlock_unlock(&self->lock);
- return (res);
+ return res;
}
static void *poll_worker(__attribute__((unused)) void *arg) {
mcelog_thread_running = 0;
pthread_cleanup_pop(1);
- return (NULL);
+ return NULL;
}
static int mcelog_init(void) {
if (socket_adapter.reinit(&socket_adapter) != 0) {
ERROR(MCELOG_PLUGIN ": Cannot connect to client socket");
- return (-1);
+ return -1;
}
if (plugin_thread_create(&g_mcelog_config.tid, NULL, poll_worker, NULL,
NULL) != 0) {
ERROR(MCELOG_PLUGIN ": Error creating poll thread.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static int get_memory_machine_checks(void) {
ERROR(MCELOG_PLUGIN ": SENT DUMP REQUEST FAILED");
else
DEBUG(MCELOG_PLUGIN ": SENT DUMP REQUEST OK");
- return (ret);
+ return ret;
}
static int mcelog_read(__attribute__((unused)) user_data_t *ud) {
if (get_memory_machine_checks() != 0)
ERROR(MCELOG_PLUGIN ": MACHINE CHECK INFO NOT AVAILABLE");
- return (0);
+ return 0;
}
static int mcelog_shutdown(void) {
ret = socket_adapter.close(&socket_adapter) || ret;
pthread_rwlock_destroy(&(socket_adapter.lock));
- return (-ret);
+ return -ret;
}
void module_register(void) {
diff --git a/src/md.c b/src/md.c
index 5e6b3ac7d5c59ca3f5ce7b899a844ceb3147b4f1..98cef1d4da3b772d907802ca88be1736c931978e 100644 (file)
--- a/src/md.c
+++ b/src/md.c
if (ignorelist == NULL)
ignorelist = ignorelist_create(/* invert = */ 1);
if (ignorelist == NULL)
- return (1);
+ return 1;
if (strcasecmp(key, "Device") == 0) {
ignorelist_add(ignorelist, value);
} else if (strcasecmp(key, "IgnoreSelected") == 0) {
ignorelist_set_invert(ignorelist, IS_TRUE(value) ? 0 : 1);
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void md_submit(const int minor, const char *type_instance,
char errbuf[1024];
WARNING("md: Unable to open %s: %s", PROC_DISKSTATS,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* Iterate md devices */
fclose(fh);
- return (0);
+ return 0;
} /* int md_read */
void module_register(void) {
diff --git a/src/memcachec.c b/src/memcachec.c
index 19228efef5c7dc4e90c33eba7e72ad84ee1e779c..c2147fd51b1f98025d26ec64bd34195495834828 100644 (file)
--- a/src/memcachec.c
+++ b/src/memcachec.c
wp->memc = memcached_create(NULL);
if (wp->memc == NULL) {
ERROR("memcachec plugin: memcached_create failed.");
- return (-1);
+ return -1;
}
server = memcached_servers_parse(wp->server);
memcached_server_push(wp->memc, server);
memcached_server_list_free(server);
- return (0);
+ return 0;
} /* }}} int cmc_page_init_memc */
static int cmc_config_add_string(const char *name, char **dest, /* {{{ */
oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("memcachec plugin: `%s' needs exactly one string argument.", name);
- return (-1);
+ return -1;
}
sfree(*dest);
*dest = strdup(ci->values[0].value.string);
if (*dest == NULL)
- return (-1);
+ return -1;
- return (0);
+ return 0;
} /* }}} int cmc_config_add_string */
static int cmc_config_add_match_dstype(int *dstype_ret, /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("memcachec plugin: `DSType' needs exactly one string argument.");
- return (-1);
+ return -1;
}
if (strncasecmp("Gauge", ci->values[0].value.string, strlen("Gauge")) == 0) {
if (dstype == 0) {
WARNING("memcachec plugin: `%s' is not a valid argument to `DSType'.",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
*dstype_ret = dstype;
- return (0);
+ return 0;
} /* }}} int cmc_config_add_match_dstype */
static int cmc_config_add_match(web_page_t *page, /* {{{ */
match = calloc(1, sizeof(*match));
if (match == NULL) {
ERROR("memcachec plugin: calloc failed.");
- return (-1);
+ return -1;
}
status = 0;
if (status != 0) {
cmc_web_match_free(match);
- return (status);
+ return status;
}
match->match =
if (match->match == NULL) {
ERROR("memcachec plugin: match_create_simple failed.");
cmc_web_match_free(match);
- return (-1);
+ return -1;
} else {
web_match_t *prev;
prev->next = match;
}
- return (0);
+ return 0;
} /* }}} int cmc_config_add_match */
static int cmc_config_add_page(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING(
"memcachec plugin: `Page' blocks need exactly one string argument.");
- return (-1);
+ return -1;
}
page = calloc(1, sizeof(*page));
if (page == NULL) {
ERROR("memcachec plugin: calloc failed.");
- return (-1);
+ return -1;
}
page->server = NULL;
page->key = NULL;
if (page->instance == NULL) {
ERROR("memcachec plugin: strdup failed.");
sfree(page);
- return (-1);
+ return -1;
}
/* Process all children */
if (status != 0) {
cmc_web_page_free(page);
- return (status);
+ return status;
}
/* Add the new page to the linked list */
prev->next = page;
}
- return (0);
+ return 0;
} /* }}} int cmc_config_add_page */
static int cmc_config(oconfig_item_t *ci) /* {{{ */
if ((success == 0) && (errors > 0)) {
ERROR("memcachec plugin: All statements failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cmc_config */
static int cmc_init(void) /* {{{ */
{
if (pages_g == NULL) {
INFO("memcachec plugin: No pages have been defined.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cmc_init */
static void cmc_submit(const web_page_t *wp, const web_match_t *wm, /* {{{ */
int status;
if (wp->memc == NULL)
- return (-1);
+ return -1;
wp->buffer = memcached_get(wp->memc, wp->key, strlen(wp->key), &string_length,
&flags, &rc);
if (rc != MEMCACHED_SUCCESS) {
ERROR("memcachec plugin: memcached_get failed: %s",
memcached_strerror(wp->memc, rc));
- return (-1);
+ return -1;
}
for (web_match_t *wm = wp->matches; wm != NULL; wm = wm->next) {
sfree(wp->buffer);
- return (0);
+ return 0;
} /* }}} int cmc_read_page */
static int cmc_read(void) /* {{{ */
for (web_page_t *wp = pages_g; wp != NULL; wp = wp->next)
cmc_read_page(wp);
- return (0);
+ return 0;
} /* }}} int cmc_read */
static int cmc_shutdown(void) /* {{{ */
cmc_web_page_free(pages_g);
pages_g = NULL;
- return (0);
+ return 0;
} /* }}} int cmc_shutdown */
void module_register(void) {
diff --git a/src/memcached.c b/src/memcached.c
index 79c38a798ec99e99203e0fa422534fd4fbd94023..5933bd480c1319d493514d6f8fad56e7e0acfe31 100644 (file)
--- a/src/memcached.c
+++ b/src/memcached.c
char errbuf[1024];
ERROR("memcached plugin: memcached_connect_unix: socket(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* connect to the memcached daemon */
fd = -1;
}
- return (fd);
+ return fd;
} /* int memcached_connect_unix */
static int memcached_connect_inet(memcached_t *st) {
st->connhost, st->connport,
(status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(status));
- return (-1);
+ return -1;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
}
freeaddrinfo(ai_list);
- return (fd);
+ return fd;
} /* int memcached_connect_inet */
static int memcached_connect(memcached_t *st) {
if (st->socket != NULL)
- return (memcached_connect_unix(st));
+ return memcached_connect_unix(st);
else
- return (memcached_connect_inet(st));
+ return memcached_connect_inet(st);
}
static int memcached_query_daemon(char *buffer, size_t buffer_size,
sstrerror(errno, errbuf, sizeof(errbuf)));
shutdown(fd, SHUT_RDWR);
close(fd);
- return (-1);
+ return -1;
}
/* receive data from the memcached daemon */
sstrerror(errno, errbuf, sizeof(errbuf)));
shutdown(fd, SHUT_RDWR);
close(fd);
- return (-1);
+ return -1;
}
buffer_fill += (size_t)status;
shutdown(fd, SHUT_RDWR);
close(fd);
- return (status);
+ return status;
} /* int memcached_query_daemon */
static void memcached_init_vl(value_list_t *vl, memcached_t const *st) {
if (st->host) {
st->connhost = strdup(st->host);
if (st->connhost == NULL)
- return (ENOMEM);
+ return ENOMEM;
if ((strcmp("127.0.0.1", st->host) == 0) ||
(strcmp("localhost", st->host) == 0))
} else {
st->connhost = strdup(MEMCACHED_DEF_HOST);
if (st->connhost == NULL)
- return (ENOMEM);
+ return ENOMEM;
}
}
if (st->connport == NULL) {
st->connport = strdup(MEMCACHED_DEF_PORT);
if (st->connport == NULL)
- return (ENOMEM);
+ return ENOMEM;
}
assert(st->connhost != NULL);
.data = st, .free_func = memcached_free,
});
- return (status);
+ return status;
} /* int memcached_add_read_callback */
/* Configuration handling functiions
st = calloc(1, sizeof(*st));
if (st == NULL) {
ERROR("memcached plugin: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
st->name = NULL;
if (status != 0) {
sfree(st);
- return (status);
+ return status;
}
for (int i = 0; i < ci->children_num; i++) {
if (status != 0) {
memcached_free(st);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static int memcached_config(oconfig_item_t *ci) {
} else if (!have_instance_block) {
/* Non-instance option: Assume legacy configuration (without <Instance />
* blocks) and call config_add_instance() with the <Plugin /> block. */
- return (config_add_instance(ci));
+ return config_add_instance(ci);
} else
WARNING("memcached plugin: The configuration option "
"\"%s\" is not allowed here. Did you "
child->key);
} /* for (ci->children) */
- return (status);
+ return status;
}
static int memcached_init(void) {
int status;
if (memcached_have_instances)
- return (0);
+ return 0;
/* No instances were configured, lets start a default instance. */
st = calloc(1, sizeof(*st));
if (st == NULL)
- return (ENOMEM);
+ return ENOMEM;
st->name = NULL;
st->host = NULL;
st->socket = NULL;
else
memcached_free(st);
- return (status);
+ return status;
} /* int memcached_init */
void module_register(void) {
diff --git a/src/memory.c b/src/memory.c
index 14b3559964f22041665b13b6eb3d91bf7f481a8e..e49fe84a103ae90657db4b86a1e7d2b95fecc285 100644 (file)
--- a/src/memory.c
+++ b/src/memory.c
child->key);
}
- return (0);
+ return 0;
} /* }}} int memory_config */
static int memory_init(void) {
pagesize = getpagesize();
if (get_kstat(&ksp, "unix", 0, "system_pages") != 0) {
ksp = NULL;
- return (-1);
+ return -1;
}
if (get_kstat(&ksz, "zfs", 0, "arcstats") != 0) {
ksz = NULL;
- return (-1);
+ return -1;
}
/* #endif HAVE_LIBKSTAT */
pagesize = getpagesize();
if (pagesize <= 0) {
ERROR("memory plugin: Invalid pagesize: %i", pagesize);
- return (-1);
+ return -1;
}
/* #endif HAVE_SYSCTL */
#elif HAVE_PERFSTAT
pagesize = getpagesize();
#endif /* HAVE_PERFSTAT */
- return (0);
+ return 0;
} /* int memory_init */
#define MEMORY_SUBMIT(...) \
gauge_t free;
if (!port_host || !pagesize)
- return (-1);
+ return -1;
vm_data_len = sizeof(vm_data) / sizeof(natural_t);
if ((status = host_statistics(port_host, HOST_VM_INFO, (host_info_t)&vm_data,
&vm_data_len)) != KERN_SUCCESS) {
ERROR("memory-plugin: host_statistics failed and returned the value %i",
(int)status);
- return (-1);
+ return -1;
}
/*
if ((fh = fopen("/proc/meminfo", "r")) == NULL) {
char errbuf[1024];
WARNING("memory: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
}
if (mem_total < (mem_free + mem_buffered + mem_cached + mem_slab_total))
- return (-1);
+ return -1;
mem_used =
mem_total - (mem_free + mem_buffered + mem_cached + mem_slab_total);
long long availrmem;
if (ksp == NULL)
- return (-1);
+ return -1;
if (ksz == NULL)
- return (-1);
+ return -1;
mem_used = get_kstat_value(ksp, "pagestotal");
mem_free = get_kstat_value(ksp, "pagesfree");
if ((mem_used < 0LL) || (mem_free < 0LL) || (mem_lock < 0LL)) {
WARNING("memory plugin: one of used, free or locked is negative.");
- return (-1);
+ return -1;
}
mem_unus = physmem - mem_used;
char errbuf[1024];
WARNING("memory plugin: sysctl failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
assert(pagesize > 0);
ios = sg_get_mem_stats();
if (ios == NULL)
- return (-1);
+ return -1;
MEMORY_SUBMIT("used", (gauge_t)ios->used, "cached", (gauge_t)ios->cache,
"free", (gauge_t)ios->free);
char errbuf[1024];
WARNING("memory plugin: perfstat_memory_total failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* Unfortunately, the AIX documentation is not very clear on how these
(gauge_t)(pmemory.real_process * pagesize));
#endif /* HAVE_PERFSTAT */
- return (0);
+ return 0;
} /* }}} int memory_read_internal */
static int memory_read(void) /* {{{ */
sstrncpy(vl.type, "memory", sizeof(vl.type));
vl.time = cdtime();
- return (memory_read_internal(&vl));
+ return memory_read_internal(&vl);
} /* }}} int memory_read */
void module_register(void) {
diff --git a/src/mic.c b/src/mic.c
index bc99e679ea44a0070b5144bde07f9bf30f2fa0d4..90a61789f214fb9801828af8e1f90976fddd6aa2 100644 (file)
--- a/src/mic.c
+++ b/src/mic.c
U32 mic_count;
if (mic_handle)
- return (0);
+ return 0;
mic_count = (U32)STATIC_ARRAY_SIZE(mics);
ret = MicInitAPI(&mic_handle, eTARGET_SCIF_DRIVER, mics, &mic_count);
if (mic_count < 0 || mic_count >= MAX_MICS) {
ERROR("mic plugin: No Intel MICs in system");
- return (1);
+ return 1;
} else {
num_mics = mic_count;
- return (0);
+ return 0;
}
}
if (power_ignore == NULL)
power_ignore = ignorelist_create(1);
if (temp_ignore == NULL || power_ignore == NULL)
- return (1);
+ return 1;
if (strcasecmp("ShowCPU", key) == 0) {
show_cpu = IS_TRUE(value);
invert = 0;
ignorelist_set_invert(power_ignore, invert);
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void mic_submit_memory_use(int micnumber, const char *type_instance,
if (ret != MIC_ACCESS_API_SUCCESS) {
ERROR("mic plugin: Problem getting Memory Utilization: %s",
MicGetErrorString(ret));
- return (1);
+ return 1;
}
mic_submit_memory_use(mic, "free", mem_free);
mic_submit_memory_use(mic, "used", mem_total - mem_free - mem_bufs);
mic_submit_memory_use(mic, "buffered", mem_bufs);
DEBUG("mic plugin: Memory Read: %u %u %u", mem_total, mem_free, mem_bufs);
- return (0);
+ return 0;
}
static void mic_submit_temp(int micnumber, const char *type, gauge_t value) {
ERROR("mic plugin: Error reading temperature \"%s\": "
"%s",
name, MicGetErrorString(status));
- return (1);
+ return 1;
}
mic_submit_temp(mic, name, temp_buffer);
}
- return (0);
+ return 0;
}
static void mic_submit_cpu(int micnumber, const char *type_instance, int core,
if (status != MIC_ACCESS_API_SUCCESS) {
ERROR("mic plugin: Problem getting CPU utilization: %s",
MicGetErrorString(status));
- return (-1);
+ return -1;
}
if (show_cpu) {
mic_submit_cpu(mic, "idle", j, core_jiffs[j].idle);
}
}
- return (0);
+ return 0;
}
static void mic_submit_power(int micnumber, const char *type,
if (ret != MIC_ACCESS_API_SUCCESS) {
ERROR("mic plugin: Problem getting Power Usage: %s",
MicGetErrorString(ret));
- return (1);
+ return 1;
}
/* power is in uWatts, current in mA, voltage in uVolts.. convert to
SUB_VOLTS(vddg);
SUB_VOLTS(vddq);
- return (0);
+ return 0;
}
static int mic_read(void) {
MicCloseAPI(&mic_handle);
mic_handle = NULL;
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/modbus.c b/src/modbus.c
index 80a2aca17953e0735d36006a976cc0908d0f64b4..f45fe21c3f4e6445e91cc5d28432534f235a479d 100644 (file)
--- a/src/modbus.c
+++ b/src/modbus.c
static mb_data_t *data_get_by_name(mb_data_t *src, /* {{{ */
const char *name) {
if (name == NULL)
- return (NULL);
+ return NULL;
for (mb_data_t *ptr = src; ptr != NULL; ptr = ptr->next)
if (strcasecmp(ptr->name, name) == 0)
- return (ptr);
+ return ptr;
- return (NULL);
+ return NULL;
} /* }}} mb_data_t *data_get_by_name */
static int data_append(mb_data_t **dst, mb_data_t *src) /* {{{ */
mb_data_t *ptr;
if ((dst == NULL) || (src == NULL))
- return (EINVAL);
+ return EINVAL;
ptr = *dst;
if (ptr == NULL) {
*dst = src;
- return (0);
+ return 0;
}
while (ptr->next != NULL)
ptr->next = src;
- return (0);
+ return 0;
} /* }}} int data_append */
/* Copy a single mb_data_t and append it to another list. */
int status;
if ((dst == NULL) || (src == NULL))
- return (EINVAL);
+ return EINVAL;
tmp = malloc(sizeof(*tmp));
if (tmp == NULL)
- return (ENOMEM);
+ return ENOMEM;
memcpy(tmp, src, sizeof(*tmp));
tmp->name = NULL;
tmp->next = NULL;
tmp->name = strdup(src->name);
if (tmp->name == NULL) {
sfree(tmp);
- return (ENOMEM);
+ return ENOMEM;
}
status = data_append(dst, tmp);
if (status != 0) {
sfree(tmp->name);
sfree(tmp);
- return (status);
+ return status;
}
- return (0);
+ return 0;
} /* }}} int data_copy */
/* Lookup a single mb_data_t instance, copy it and append the copy to another
mb_data_t *ptr;
if ((dst == NULL) || (src == NULL) || (name == NULL))
- return (EINVAL);
+ return EINVAL;
ptr = data_get_by_name(src, name);
if (ptr == NULL)
- return (ENOENT);
+ return ENOENT;
- return (data_copy(dst, ptr));
+ return data_copy(dst, ptr);
} /* }}} int data_copy_by_name */
/* Read functions */
value_list_t vl = VALUE_LIST_INIT;
if ((host == NULL) || (slave == NULL) || (data == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->interval == 0)
host->interval = plugin_get_interval();
sstrncpy(vl.type, data->type, sizeof(vl.type));
sstrncpy(vl.type_instance, data->instance, sizeof(vl.type_instance));
- return (plugin_dispatch_values(&vl));
+ return plugin_dispatch_values(&vl);
} /* }}} int mb_submit */
static float mb_register_to_float(uint16_t hi, uint16_t lo) /* {{{ */
conv.b[0] = (hi >> 8) & 0x00ff;
#endif
- return (conv.f);
+ return conv.f;
} /* }}} float mb_register_to_float */
#if LEGACY_LIBMODBUS
int status;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
#if COLLECT_DEBUG
modbus_set_debug(&host->connection, 1);
if (status != 0) {
ERROR("Modbus plugin: modbus_connect (%s, %i) failed with status %i.",
host->node, host->port ? host->port : host->baudrate, status);
- return (status);
+ return status;
}
host->is_connected = 1;
- return (0);
+ return 0;
} /* }}} int mb_init_connection */
/* #endif LEGACY_LIBMODBUS */
int status;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
if (host->connection != NULL)
- return (0);
+ return 0;
if (host->conntype == MBCONN_TCP) {
if ((host->port < 1) || (host->port > 65535))
host->connection = modbus_new_tcp(host->node, host->port);
if (host->connection == NULL) {
ERROR("Modbus plugin: Creating new Modbus/TCP object failed.");
- return (-1);
+ return -1;
}
} else {
DEBUG("Modbus plugin: Trying to connect to \"%s\", baudrate %i.",
host->connection = modbus_new_rtu(host->node, host->baudrate, 'N', 8, 1);
if (host->connection == NULL) {
ERROR("Modbus plugin: Creating new Modbus/RTU object failed.");
- return (-1);
+ return -1;
}
}
host->node, host->port ? host->port : host->baudrate, status);
modbus_free(host->connection);
host->connection = NULL;
- return (status);
+ return status;
}
- return (0);
+ return 0;
} /* }}} int mb_init_connection */
#endif /* !LEGACY_LIBMODBUS */
int status = 0;
if ((host == NULL) || (slave == NULL) || (data == NULL))
- return (EINVAL);
+ return EINVAL;
ds = plugin_get_ds(data->type);
if (ds == NULL) {
ERROR("Modbus plugin: Type \"%s\" is not defined.", data->type);
- return (-1);
+ return -1;
}
if (ds->ds_num != 1) {
ERROR("Modbus plugin: The type \"%s\" has %zu data sources. "
"I can only handle data sets with only one data source.",
data->type, ds->ds_num);
- return (-1);
+ return -1;
}
if ((ds->ds[0].type != DS_TYPE_GAUGE) &&
host->node);
host->is_connected = 0;
host->connection = NULL;
- return (-1);
+ return -1;
}
} else if (status != 0) {
#if LEGACY_LIBMODBUS
if (status != 0) {
ERROR("Modbus plugin: modbus_set_slave (%i) failed with status %i.",
slave->id, status);
- return (-1);
+ return -1;
}
#endif
if (data->modbus_register_type == MREG_INPUT) {
modbus_free(host->connection);
#endif
host->connection = NULL;
- return (-1);
+ return -1;
}
DEBUG("Modbus plugin: mb_read_data: Success! "
mb_submit(host, slave, data, vt);
}
- return (0);
+ return 0;
} /* }}} int mb_read_data */
static int mb_read_slave(mb_host_t *host, mb_slave_t *slave) /* {{{ */
int status;
if ((host == NULL) || (slave == NULL))
- return (EINVAL);
+ return EINVAL;
success = 0;
for (mb_data_t *data = slave->collect; data != NULL; data = data->next) {
}
if (success == 0)
- return (-1);
+ return -1;
else
- return (0);
+ return 0;
} /* }}} int mb_read_slave */
static int mb_read(user_data_t *user_data) /* {{{ */
int status;
if ((user_data == NULL) || (user_data->data == NULL))
- return (EINVAL);
+ return EINVAL;
host = user_data->data;
}
if (success == 0)
- return (-1);
+ return -1;
else
- return (0);
+ return 0;
} /* }}} int mb_read */
/* Free functions */
status = cf_util_get_string(ci, &data.name);
if (status != 0)
- return (status);
+ return status;
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
sfree(data.name);
- return (status);
+ return status;
} /* }}} int mb_config_add_data */
static int mb_config_set_host_address(mb_host_t *host, /* {{{ */
int status;
if ((host == NULL) || (address == NULL))
- return (EINVAL);
+ return EINVAL;
struct addrinfo ai_hints = {
/* XXX: libmodbus can only handle IPv4 addresses. */
ERROR("Modbus plugin: getaddrinfo failed: %s",
(status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(status));
- return (status);
+ return status;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
host->node);
}
- return (status);
+ return status;
} /* }}} int mb_config_set_host_address */
static int mb_config_add_slave(mb_host_t *host, oconfig_item_t *ci) /* {{{ */
int status;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
slave = realloc(host->slaves, sizeof(*slave) * (host->slaves_num + 1));
if (slave == NULL)
- return (ENOMEM);
+ return ENOMEM;
host->slaves = slave;
slave = host->slaves + host->slaves_num;
memset(slave, 0, sizeof(*slave));
status = cf_util_get_int(ci, &slave->id);
if (status != 0)
- return (status);
+ return status;
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
else /* if (status != 0) */
data_free_all(slave->collect);
- return (status);
+ return status;
} /* }}} int mb_config_add_slave */
static int mb_config_add_host(oconfig_item_t *ci) /* {{{ */
host = calloc(1, sizeof(*host));
if (host == NULL)
- return (ENOMEM);
+ return ENOMEM;
host->slaves = NULL;
status = cf_util_get_string_buffer(ci, host->host, sizeof(host->host));
if (status != 0) {
sfree(host);
- return (status);
+ return status;
}
if (host->host[0] == 0) {
sfree(host);
- return (EINVAL);
+ return EINVAL;
}
for (int i = 0; i < ci->children_num; i++) {
host_free(host);
}
- return (status);
+ return status;
} /* }}} int mb_config_add_host */
static int mb_config(oconfig_item_t *ci) /* {{{ */
{
if (ci == NULL)
- return (EINVAL);
+ return EINVAL;
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
ERROR("Modbus plugin: Unknown configuration option: %s", child->key);
}
- return (0);
+ return 0;
} /* }}} int mb_config */
/* ========= */
data_free_all(data_definitions);
data_definitions = NULL;
- return (0);
+ return 0;
} /* }}} int mb_shutdown */
void module_register(void) {
diff --git a/src/mqtt.c b/src/mqtt.c
index a962514ce1b122f93503d9516928de8a3411579a..36e657786fb59818e5ebc751c36395551d73b32a 100644 (file)
--- a/src/mqtt.c
+++ b/src/mqtt.c
num++;
if (num < 2)
- return (NULL);
+ return NULL;
while (num > 2) {
char *tmp = strchr(topic, '/');
if (tmp == NULL)
- return (NULL);
+ return NULL;
topic = tmp + 1;
num--;
}
- return (topic);
+ return topic;
}
static void on_message(
int status;
if (conf->connected)
- return (0);
+ return 0;
status = mosquitto_reconnect(conf->mosq);
if (status != MOSQ_ERR_SUCCESS) {
ERROR("mqtt_connect_broker: mosquitto_connect failed: %s",
(status == MOSQ_ERR_ERRNO) ? sstrerror(errno, errbuf, sizeof(errbuf))
: mosquitto_strerror(status));
- return (-1);
+ return -1;
}
conf->connected = 1;
"mqtt plugin: successfully reconnected to broker \"%s:%d\"",
conf->host, conf->port);
- return (0);
+ return 0;
} /* mqtt_reconnect */
/* must hold conf->lock when calling. */
#endif
if (conf->mosq == NULL) {
ERROR("mqtt plugin: mosquitto_new failed");
- return (-1);
+ return -1;
}
#if LIBMOSQUITTO_MAJOR != 0
mosquitto_strerror(status));
mosquitto_destroy(conf->mosq);
conf->mosq = NULL;
- return (-1);
+ return -1;
}
status = mosquitto_tls_opts_set(conf->mosq, SSL_VERIFY_PEER,
mosquitto_strerror(status));
mosquitto_destroy(conf->mosq);
conf->mosq = NULL;
- return (-1);
+ return -1;
}
status = mosquitto_tls_insecure_set(conf->mosq, false);
mosquitto_strerror(status));
mosquitto_destroy(conf->mosq);
conf->mosq = NULL;
- return (-1);
+ return -1;
}
}
#endif
mosquitto_destroy(conf->mosq);
conf->mosq = NULL;
- return (-1);
+ return -1;
}
}
mosquitto_destroy(conf->mosq);
conf->mosq = NULL;
- return (-1);
+ return -1;
}
if (!conf->publish) {
mosquitto_disconnect(conf->mosq);
mosquitto_destroy(conf->mosq);
conf->mosq = NULL;
- return (-1);
+ return -1;
}
}
conf->connected = 1;
- return (0);
+ return 0;
} /* mqtt_connect */
static void *subscribers_thread(void *arg) {
if (status != 0) {
pthread_mutex_unlock(&conf->lock);
ERROR("mqtt plugin: unable to reconnect to broker");
- return (status);
+ return status;
}
status = mosquitto_publish(conf->mosq, /* message_id */ NULL, topic,
mosquitto_disconnect(conf->mosq);
pthread_mutex_unlock(&conf->lock);
- return (-1);
+ return -1;
}
pthread_mutex_unlock(&conf->lock);
- return (0);
+ return 0;
} /* int publish */
static int format_topic(char *buf, size_t buf_len, data_set_t const *ds,
char *c;
if ((conf->topic_prefix == NULL) || (conf->topic_prefix[0] == 0))
- return (FORMAT_VL(buf, buf_len, vl));
+ return FORMAT_VL(buf, buf_len, vl);
status = FORMAT_VL(name, sizeof(name), vl);
if (status != 0)
- return (status);
+ return status;
status = ssnprintf(buf, buf_len, "%s/%s", conf->topic_prefix, name);
if ((status < 0) || (((size_t)status) >= buf_len))
- return (ENOMEM);
+ return ENOMEM;
while((c = strchr(buf, '#')) || (c = strchr(buf, '+'))) {
*c = '_';
}
- return (0);
+ return 0;
} /* int format_topic */
static int mqtt_write(const data_set_t *ds, const value_list_t *vl,
int status = 0;
if ((user_data == NULL) || (user_data->data == NULL))
- return (EINVAL);
+ return EINVAL;
conf = user_data->data;
status = format_topic(topic, sizeof(topic), ds, vl, conf);
if (status != 0) {
ERROR("mqtt plugin: format_topic failed with status %d.", status);
- return (status);
+ return status;
}
status = format_values(payload, sizeof(payload), ds, vl, conf->store_rates);
if (status != 0) {
ERROR("mqtt plugin: format_values failed with status %d.", status);
- return (status);
+ return status;
}
status = publish(conf, topic, payload, strlen(payload) + 1);
if (status != 0) {
ERROR("mqtt plugin: publish failed: %s", mosquitto_strerror(status));
- return (status);
+ return status;
}
- return (status);
+ return status;
} /* mqtt_write */
/*
conf = calloc(1, sizeof(*conf));
if (conf == NULL) {
ERROR("mqtt plugin: calloc failed.");
- return (-1);
+ return -1;
}
conf->publish = 1;
status = cf_util_get_string(ci, &conf->name);
if (status != 0) {
mqtt_free(conf);
- return (status);
+ return status;
}
conf->host = strdup(MQTT_DEFAULT_HOST);
status = pthread_mutex_init(&conf->lock, NULL);
if (status != 0) {
mqtt_free(conf);
- return (status);
+ return status;
}
C_COMPLAIN_INIT(&conf->complaint_cantpublish);
plugin_register_write(cb_name, mqtt_write, &(user_data_t){
.data = conf,
});
- return (0);
+ return 0;
} /* mqtt_config_publisher */
/*
conf = calloc(1, sizeof(*conf));
if (conf == NULL) {
ERROR("mqtt plugin: calloc failed.");
- return (-1);
+ return -1;
}
conf->publish = 0;
status = cf_util_get_string(ci, &conf->name);
if (status != 0) {
mqtt_free(conf);
- return (status);
+ return status;
}
conf->host = strdup(MQTT_DEFAULT_HOST);
status = pthread_mutex_init(&conf->lock, NULL);
if (status != 0) {
mqtt_free(conf);
- return (status);
+ return status;
}
C_COMPLAIN_INIT(&conf->complaint_cantpublish);
if (tmp == NULL) {
ERROR("mqtt plugin: realloc failed.");
mqtt_free(conf);
- return (-1);
+ return -1;
}
subscribers = tmp;
subscribers[subscribers_num] = conf;
subscribers_num++;
- return (0);
+ return 0;
} /* mqtt_config_subscriber */
/*
ERROR("mqtt plugin: Unknown config option: %s", child->key);
}
- return (0);
+ return 0;
} /* int mqtt_config */
static int mqtt_init(void) {
}
}
- return (0);
+ return 0;
} /* mqtt_init */
void module_register(void) {
diff --git a/src/multimeter.c b/src/multimeter.c
index 93ab3d29a31617ba2387c0fbd8d68780879aa604..72b0fed91c1f32caab8ec7b2846389d70031b513 100644 (file)
--- a/src/multimeter.c
+++ b/src/multimeter.c
char errbuf[1024];
ERROR("multimeter plugin: gettimeofday failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
time_end.tv_sec++;
status = swrite(fd, "D", 1);
if (status < 0) {
ERROR("multimeter plugin: swrite failed.");
- return (-1);
+ return -1;
}
FD_ZERO(&rfds);
ERROR("multimeter plugin: "
"gettimeofday failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (timeval_cmp(time_end, time_now, &timeout) < 0)
break;
break;
}
} else
- return (-1); /* Overflow */
+ return -1; /* Overflow */
- return (0); /* value received */
+ return 0; /* value received */
} else
break;
} else if (!status) /* Timeout */
}
} while (--retry);
- return (-2); /* no value received */
+ return -2; /* no value received */
} /* int multimeter_read_value */
static int multimeter_init(void) {
INFO("multimeter plugin: Device "
"found at %s",
device);
- return (0);
+ return 0;
}
}
}
ERROR("multimeter plugin: No device found");
- return (-1);
+ return -1;
}
#undef LINE_LENGTH
double value;
if (fd < 0)
- return (-1);
+ return -1;
if (multimeter_read_value(&value) != 0)
- return (-1);
+ return -1;
multimeter_submit(value);
- return (0);
+ return 0;
} /* int multimeter_read */
static int multimeter_shutdown(void) {
fd = -1;
}
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/mysql.c b/src/mysql.c
index 8409d1b66b1337c72e0fc2b0a3745051828a1b87..b6edce0d36115192752fe2a12bb9b4f3f864e27f 100644 (file)
--- a/src/mysql.c
+++ b/src/mysql.c
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("mysql plugin: The `Database' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
db = calloc(1, sizeof(*db));
if (db == NULL) {
ERROR("mysql plugin: calloc failed.");
- return (-1);
+ return -1;
}
/* initialize all the pointers */
status = cf_util_get_string(ci, &db->instance);
if (status != 0) {
sfree(db);
- return (status);
+ return status;
}
assert(db->instance != NULL);
});
} else {
mysql_database_free(db);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int mysql_config_database */
static int mysql_config(oconfig_item_t *ci) /* {{{ */
{
if (ci == NULL)
- return (EINVAL);
+ return EINVAL;
/* Fill the `mysql_database_t' structure.. */
for (int i = 0; i < ci->children_num; i++) {
WARNING("mysql plugin: Option \"%s\" not allowed here.", child->key);
}
- return (0);
+ return 0;
} /* }}} int mysql_config */
/* }}} End of configuration handling functions */
status = mysql_ping(db->con);
if (status == 0)
- return (db->con);
+ return db->con;
WARNING("mysql plugin: Lost connection to instance \"%s\": %s",
db->instance, mysql_error(db->con));
db->con = mysql_init(NULL);
if (db->con == NULL) {
ERROR("mysql plugin: mysql_init failed: %s", mysql_error(db->con));
- return (NULL);
+ return NULL;
}
}
"at server %s: %s",
(db->database != NULL) ? db->database : "<none>",
(db->host != NULL) ? db->host : "localhost", mysql_error(db->con));
- return (NULL);
+ return NULL;
}
cipher = mysql_get_ssl_cipher(db->con);
mysql_get_server_info(db->con), mysql_get_proto_info(db->con));
db->is_connected = 1;
- return (db->con);
+ return db->con;
} /* static MYSQL *getconnection (mysql_database_t *db) */
static void set_host(mysql_database_t *db, char *buf, size_t buflen) {
if (mysql_real_query(con, query, query_len)) {
ERROR("mysql plugin: Failed to execute query: %s", mysql_error(con));
INFO("mysql plugin: SQL query was: %s", query);
- return (NULL);
+ return NULL;
}
res = mysql_store_result(con);
if (res == NULL) {
ERROR("mysql plugin: Failed to store query result: %s", mysql_error(con));
INFO("mysql plugin: SQL query was: %s", query);
- return (NULL);
+ return NULL;
}
- return (res);
+ return res;
} /* exec_query */
static int mysql_read_master_stats(mysql_database_t *db, MYSQL *con) {
res = exec_query(con, query);
if (res == NULL)
- return (-1);
+ return -1;
row = mysql_fetch_row(res);
if (row == NULL) {
"`%s' did not return any rows.",
query);
mysql_free_result(res);
- return (-1);
+ return -1;
}
field_num = mysql_num_fields(res);
"`%s' returned less than two columns.",
query);
mysql_free_result(res);
- return (-1);
+ return -1;
}
position = atoll(row[1]);
mysql_free_result(res);
- return (0);
+ return 0;
} /* mysql_read_master_stats */
static int mysql_read_slave_stats(mysql_database_t *db, MYSQL *con) {
res = exec_query(con, query);
if (res == NULL)
- return (-1);
+ return -1;
row = mysql_fetch_row(res);
if (row == NULL) {
"`%s' did not return any rows.",
query);
mysql_free_result(res);
- return (-1);
+ return -1;
}
field_num = mysql_num_fields(res);
"`%s' returned less than 33 columns.",
query);
mysql_free_result(res);
- return (-1);
+ return -1;
}
if (db->slave_stats) {
mysql_free_result(res);
- return (0);
+ return 0;
} /* mysql_read_slave_stats */
static int mysql_read_innodb_stats(mysql_database_t *db, MYSQL *con) {
res = exec_query(con, query);
if (res == NULL)
- return (-1);
+ return -1;
while ((row = mysql_fetch_row(res))) {
int i;
}
mysql_free_result(res);
- return (0);
+ return 0;
}
static int mysql_read_wsrep_stats(mysql_database_t *db, MYSQL *con) {
res = exec_query(con, query);
if (res == NULL)
- return (-1);
+ return -1;
row = mysql_fetch_row(res);
if (row == NULL) {
"`%s' did not return any rows.",
query);
mysql_free_result(res);
- return (-1);
+ return -1;
}
while ((row = mysql_fetch_row(res))) {
}
mysql_free_result(res);
- return (0);
+ return 0;
} /* mysql_read_wsrep_stats */
static int mysql_read(user_data_t *ud) {
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("mysql plugin: mysql_database_read: Invalid user data.");
- return (-1);
+ return -1;
}
db = (mysql_database_t *)ud->data;
/* An error message will have been printed in this case */
if ((con = getconnection(db)) == NULL)
- return (-1);
+ return -1;
mysql_version = mysql_get_server_version(con);
res = exec_query(con, query);
if (res == NULL)
- return (-1);
+ return -1;
while ((row = mysql_fetch_row(res))) {
char *key;
if (db->wsrep_stats)
mysql_read_wsrep_stats(db, con);
- return (0);
+ return 0;
} /* int mysql_read */
void module_register(void) {
diff --git a/src/netapp.c b/src/netapp.c
index 13e1db9207ed9361cbd4049260eb8782e0d40b95..701ac2f72f0864a69c0a0c6de117d4222f28d927 100644 (file)
--- a/src/netapp.c
+++ b/src/netapp.c
disk_t *d;
if ((cd == NULL) || (name == NULL))
- return (NULL);
+ return NULL;
for (d = cd->disks; d != NULL; d = d->next) {
if (strcmp(d->name, name) == 0)
d = calloc(1, sizeof(*d));
if (d == NULL)
- return (NULL);
+ return NULL;
d->next = NULL;
d->name = strdup(name);
if (d->name == NULL) {
sfree(d);
- return (NULL);
+ return NULL;
}
d->next = cd->disks;
@@ -492,12 +492,12 @@ static data_volume_usage_t *get_volume_usage(cfg_volume_usage_t *cvu, /* {{{ */
int ignore_snapshot = 0;
if ((cvu == NULL) || (name == NULL))
- return (NULL);
+ return NULL;
last = cvu->volumes;
while (last != NULL) {
if (strcmp(last->name, name) == 0)
- return (last);
+ return last;
if (last->next == NULL)
break;
@@ -510,18 +510,18 @@ static data_volume_usage_t *get_volume_usage(cfg_volume_usage_t *cvu, /* {{{ */
ignore_capacity = ignorelist_match(cvu->il_capacity, name);
ignore_snapshot = ignorelist_match(cvu->il_snapshot, name);
if ((ignore_capacity != 0) && (ignore_snapshot != 0))
- return (NULL);
+ return NULL;
/* Not found: allocate. */
new = calloc(1, sizeof(*new));
if (new == NULL)
- return (NULL);
+ return NULL;
new->next = NULL;
new->name = strdup(name);
if (new->name == NULL) {
sfree(new);
- return (NULL);
+ return NULL;
}
if (ignore_capacity == 0)
else
last->next = new;
- return (new);
+ return new;
} /* }}} data_volume_usage_t *get_volume_usage */
static data_volume_perf_t *get_volume_perf(cfg_volume_perf_t *cvp, /* {{{ */
int ignore_latency = 0;
if ((cvp == NULL) || (name == NULL))
- return (NULL);
+ return NULL;
last = cvp->volumes;
while (last != NULL) {
if (strcmp(last->name, name) == 0)
- return (last);
+ return last;
if (last->next == NULL)
break;
ignore_operations = ignorelist_match(cvp->il_operations, name);
ignore_latency = ignorelist_match(cvp->il_latency, name);
if ((ignore_octets != 0) || (ignore_operations != 0) || (ignore_latency != 0))
- return (NULL);
+ return NULL;
/* Not found: allocate. */
new = calloc(1, sizeof(*new));
if (new == NULL)
- return (NULL);
+ return NULL;
new->next = NULL;
new->name = strdup(name);
if (new->name == NULL) {
sfree(new);
- return (NULL);
+ return NULL;
}
if (ignore_octets == 0)
else
last->next = new;
- return (new);
+ return new;
} /* }}} data_volume_perf_t *get_volume_perf */
/*
if (type_inst != NULL)
sstrncpy(vl.type_instance, type_inst, sizeof(vl.type_instance));
- return (plugin_dispatch_values(&vl));
+ return plugin_dispatch_values(&vl);
} /* }}} int submit_uint64 */
static int submit_two_derive(const char *host,
{.derive = val0}, {.derive = val1},
};
- return (submit_values(host, plugin_inst, type, type_inst, values,
- STATIC_ARRAY_SIZE(values), timestamp, interval));
+ return submit_values(host, plugin_inst, type, type_inst, values,
+ STATIC_ARRAY_SIZE(values), timestamp, interval);
} /* }}} int submit_two_derive */
static int submit_derive(const char *host, const char *plugin_inst, /* {{{ */
const char *type, const char *type_inst,
derive_t counter, cdtime_t timestamp,
cdtime_t interval) {
- return (submit_values(host, plugin_inst, type, type_inst,
- &(value_t){.derive = counter}, 1, timestamp, interval));
+ return submit_values(host, plugin_inst, type, type_inst, &(value_t){
+ .derive=counter,
+ }, 1, timestamp, interval);
} /* }}} int submit_derive */
static int submit_two_gauge(const char *host, const char *plugin_inst, /* {{{ */
@@ -666,15 +667,16 @@ static int submit_two_gauge(const char *host, const char *plugin_inst, /* {{{ */
{.gauge = val0}, {.gauge = val1},
};
- return (submit_values(host, plugin_inst, type, type_inst, values,
- STATIC_ARRAY_SIZE(values), timestamp, interval));
+ return submit_values(host, plugin_inst, type, type_inst, values,
+ STATIC_ARRAY_SIZE(values), timestamp, interval);
} /* }}} int submit_two_gauge */
static int submit_double(const char *host, const char *plugin_inst, /* {{{ */
const char *type, const char *type_inst, double d,
cdtime_t timestamp, cdtime_t interval) {
- return (submit_values(host, plugin_inst, type, type_inst,
- &(value_t){.gauge = d}, 1, timestamp, interval));
+ return submit_values(host, plugin_inst, type, type_inst, &(value_t){
+ .gauge=d,
+ }, 1, timestamp, interval);
} /* }}} int submit_uint64 */
/* Calculate hit ratio from old and new counters and submit the resulting
v.gauge = 100.0 * ((gauge_t)hits) / ((gauge_t)(hits + misses));
}
- return (submit_values(host, plugin_inst, "cache_ratio", type_inst, &v, 1,
- timestamp, interval));
+ return submit_values(host, plugin_inst, "cache_ratio", type_inst, &v, 1,
+ timestamp, interval);
} /* }}} int submit_cache_ratio */
/* Submits all the caches used by WAFL. Uses "submit_cache_ratio". */
/* Copy HAVE_* flags */
old_data->flags |= (new_data->flags & HAVE_WAFL_ALL);
- return (0);
+ return 0;
} /* }}} int submit_wafl_data */
/* Submits volume performance data to the daemon, taking care to honor and
char plugin_instance[DATA_MAX_NAME_LEN];
if ((hostname == NULL) || (old_data == NULL) || (new_data == NULL))
- return (-1);
+ return -1;
ssnprintf(plugin_instance, sizeof(plugin_instance), "volume-%s",
old_data->name);
/* Copy the HAVE_* flags */
old_data->flags |= (new_data->flags & HAVE_VOLUME_PERF_ALL);
- return (0);
+ return 0;
} /* }}} int submit_volume_perf_data */
static cdtime_t cna_child_get_cdtime(na_elem_t *data) /* {{{ */
t = (time_t)na_child_get_uint64(data, "timestamp", /* default = */ 0);
- return (TIME_T_TO_CDTIME_T(t));
+ return TIME_T_TO_CDTIME_T(t);
} /* }}} cdtime_t cna_child_get_cdtime */
/*
"na_elem_child (\"instances\") failed "
"for host %s.",
hostname);
- return (-1);
+ return -1;
}
plugin_inst = na_child_get_string(instances, "name");
"na_child_get_string (\"name\") failed "
"for host %s.",
hostname);
- return (-1);
+ return -1;
}
/* Iterate over all counters */
}
}
- return (
- submit_wafl_data(hostname, plugin_inst, cfg_wafl, &perf_data, interval));
+ return submit_wafl_data(hostname, plugin_inst, cfg_wafl, &perf_data,
+ interval);
} /* }}} void cna_handle_wafl_data */
static int cna_setup_wafl(cfg_wafl_t *cw) /* {{{ */
na_elem_t *e;
if (cw == NULL)
- return (EINVAL);
+ return EINVAL;
if (cw->query != NULL)
- return (0);
+ return 0;
cw->query = na_elem_new("perf-object-get-instances");
if (cw->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(cw->query, "objectname", "wafl");
na_elem_free(cw->query);
cw->query = NULL;
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(e, "counter", "name_cache_hit");
na_child_add_string(e, "counter", "name_cache_miss");
na_child_add(cw->query, e);
- return (0);
+ return 0;
} /* }}} int cna_setup_wafl */
static int cna_query_wafl(host_config_t *host) /* {{{ */
cdtime_t now;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
/* If WAFL was not configured, return without doing anything. */
if (host->cfg_wafl == NULL)
- return (0);
+ return 0;
now = cdtime();
if ((host->cfg_wafl->interval.interval + host->cfg_wafl->interval.last_read) >
now)
- return (0);
+ return 0;
status = cna_setup_wafl(host->cfg_wafl);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_wafl->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_wafl->query);
"host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status = cna_handle_wafl_data(host->name, host->cfg_wafl, data,
host->cfg_wafl->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_wafl */
/* Data corresponding to <Disks /> */
disk_t *worst_disk = NULL;
if ((cfg_disk == NULL) || (data == NULL))
- return (EINVAL);
+ return EINVAL;
timestamp = cna_child_get_cdtime(data);
"na_elem_child (\"instances\") failed "
"for host %s.",
hostname);
- return (-1);
+ return -1;
}
/* Iterate over all children */
submit_double(hostname, "system", "percent", "disk_busy",
worst_disk->disk_busy_percent, timestamp, interval);
- return (0);
+ return 0;
} /* }}} int cna_handle_disk_data */
static int cna_setup_disk(cfg_disk_t *cd) /* {{{ */
na_elem_t *e;
if (cd == NULL)
- return (EINVAL);
+ return EINVAL;
if (cd->query != NULL)
- return (0);
+ return 0;
cd->query = na_elem_new("perf-object-get-instances");
if (cd->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(cd->query, "objectname", "disk");
na_elem_free(cd->query);
cd->query = NULL;
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(e, "counter", "disk_busy");
na_child_add_string(e, "counter", "base_for_disk_busy");
na_child_add(cd->query, e);
- return (0);
+ return 0;
} /* }}} int cna_setup_disk */
static int cna_query_disk(host_config_t *host) /* {{{ */
cdtime_t now;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
/* If the user did not configure disk statistics, return without doing
* anything. */
if (host->cfg_disk == NULL)
- return (0);
+ return 0;
now = cdtime();
if ((host->cfg_disk->interval.interval + host->cfg_disk->interval.last_read) >
now)
- return (0);
+ return 0;
status = cna_setup_disk(host->cfg_disk);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_disk->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_disk->query);
"host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status = cna_handle_disk_data(host->name, host->cfg_disk, data,
host->cfg_disk->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_disk */
/* Data corresponding to <VolumePerf /> */
"na_elem_child (\"instances\") failed "
"for host %s.",
hostname);
- return (-1);
+ return -1;
}
iter_instances = na_child_iterator(elem_instances);
submit_volume_perf_data(hostname, v, &perf_data, interval);
} /* for (volume) */
- return (0);
+ return 0;
} /* }}} int cna_handle_volume_perf_data */
static int cna_setup_volume_perf(cfg_volume_perf_t *cd) /* {{{ */
na_elem_t *e;
if (cd == NULL)
- return (EINVAL);
+ return EINVAL;
if (cd->query != NULL)
- return (0);
+ return 0;
cd->query = na_elem_new("perf-object-get-instances");
if (cd->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(cd->query, "objectname", "volume");
na_elem_free(cd->query);
cd->query = NULL;
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(e, "counter", "read_ops");
na_child_add_string(e, "counter", "write_ops");
na_child_add_string(e, "counter", "write_latency");
na_child_add(cd->query, e);
- return (0);
+ return 0;
} /* }}} int cna_setup_volume_perf */
static int cna_query_volume_perf(host_config_t *host) /* {{{ */
cdtime_t now;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
/* If the user did not configure volume performance statistics, return
* without doing anything. */
if (host->cfg_volume_perf == NULL)
- return (0);
+ return 0;
now = cdtime();
if ((host->cfg_volume_perf->interval.interval +
host->cfg_volume_perf->interval.last_read) > now)
- return (0);
+ return 0;
status = cna_setup_volume_perf(host->cfg_volume_perf);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_volume_perf->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_volume_perf->query);
"for host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status =
host->cfg_volume_perf->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_volume_perf */
/* Data corresponding to <VolumeUsage /> */
v->flags &= ~HAVE_VOLUME_USAGE_ALL;
} /* for (v = cfg_volume->volumes) */
- return (0);
+ return 0;
} /* }}} int cna_submit_volume_usage_data */
/* Switch the state of a volume between online and offline and send out a
v->flags |= IS_VOLUME_USAGE_OFFLINE;
}
- return (plugin_dispatch_notification(&n));
+ return plugin_dispatch_notification(&n);
} /* }}} int cna_change_volume_status */
static void cna_handle_volume_snap_usage(const host_config_t *host, /* {{{ */
"na_elem_child (\"volumes\") failed "
"for host %s.",
host->name);
- return (-1);
+ return -1;
}
iter_volume = na_child_iterator(elem_volumes);
@@ -1721,25 +1723,25 @@ static int cna_handle_volume_usage_data(const host_config_t *host, /* {{{ */
}
} /* for (elem_volume) */
- return (cna_submit_volume_usage_data(
- host->name, cfg_volume, host->cfg_volume_usage->interval.interval));
+ return cna_submit_volume_usage_data(host->name, cfg_volume,
+ host->cfg_volume_usage->interval.interval);
} /* }}} int cna_handle_volume_usage_data */
static int cna_setup_volume_usage(cfg_volume_usage_t *cvu) /* {{{ */
{
if (cvu == NULL)
- return (EINVAL);
+ return EINVAL;
if (cvu->query != NULL)
- return (0);
+ return 0;
cvu->query = na_elem_new("volume-list-info");
if (cvu->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cna_setup_volume_usage */
static int cna_query_volume_usage(host_config_t *host) /* {{{ */
cdtime_t now;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
/* If the user did not configure volume_usage statistics, return without
* doing anything. */
if (host->cfg_volume_usage == NULL)
- return (0);
+ return 0;
now = cdtime();
if ((host->cfg_volume_usage->interval.interval +
host->cfg_volume_usage->interval.last_read) > now)
- return (0);
+ return 0;
status = cna_setup_volume_usage(host->cfg_volume_usage);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_volume_usage->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_volume_usage->query);
"for host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status = cna_handle_volume_usage_data(host, host->cfg_volume_usage, data);
host->cfg_volume_usage->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_volume_usage */
/* Data corresponding to <Quota /> */
"na_elem_child (\"quotas\") failed "
"for host %s.",
host->name);
- return (-1);
+ return -1;
}
iter_quota = na_child_iterator(elem_quotas);
}
} /* for (elem_quota) */
- return (0);
+ return 0;
} /* }}} int cna_handle_volume_usage_data */
static int cna_setup_quota(cfg_quota_t *cq) /* {{{ */
{
if (cq == NULL)
- return (EINVAL);
+ return EINVAL;
if (cq->query != NULL)
- return (0);
+ return 0;
cq->query = na_elem_new("quota-report");
if (cq->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cna_setup_quota */
static int cna_query_quota(host_config_t *host) /* {{{ */
cdtime_t now;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
/* If the user did not configure quota statistics, return without
* doing anything. */
if (host->cfg_quota == NULL)
- return (0);
+ return 0;
now = cdtime();
if ((host->cfg_quota->interval.interval +
host->cfg_quota->interval.last_read) > now)
- return (0);
+ return 0;
status = cna_setup_quota(host->cfg_quota);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_quota->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_quota->query);
"host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status = cna_handle_quota_data(host, host->cfg_quota, data);
host->cfg_quota->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_quota */
/* Data corresponding to <SnapVault /> */
na_elem_t *status_list = na_elem_child(data, "status-list");
if (status_list == NULL) {
ERROR("netapp plugin: SnapVault status record missing status-list");
- return (0);
+ return 0;
}
na_elem_iter_t status_iter = na_child_iterator(status_list);
}
} /* for (status) */
- return (0);
+ return 0;
} /* }}} int cna_handle_snapvault_data */
static int cna_handle_snapvault_iter(host_config_t *host, /* {{{ */
"na_server_invoke failed for host %s: %s",
host->name, na_results_reason(data));
na_elem_free(elem);
- return (-1);
+ return -1;
}
cna_handle_snapvault_data(host->name, host->cfg_snapvault, elem,
na_elem_free(na_server_invoke(
host->srv, "snapvault-secondary-relationship-status-list-iter-end", "tag",
tag, NULL));
- return (0);
+ return 0;
} /* }}} int cna_handle_snapvault_iter */
static int cna_setup_snapvault(cfg_snapvault_t *sv) /* {{{ */
{
if (sv == NULL)
- return (EINVAL);
+ return EINVAL;
if (sv->query != NULL)
- return (0);
+ return 0;
sv->query =
na_elem_new("snapvault-secondary-relationship-status-list-iter-start");
if (sv->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cna_setup_snapvault */
static int cna_query_snapvault(host_config_t *host) /* {{{ */
now = cdtime();
if ((host->cfg_snapvault->interval.interval +
host->cfg_snapvault->interval.last_read) > now)
- return (0);
+ return 0;
status = cna_setup_snapvault(host->cfg_snapvault);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_snapvault->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_snapvault->query);
"for host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status = cna_handle_snapvault_iter(host, data);
host->cfg_snapvault->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_snapvault */
/* Data corresponding to <System /> */
"na_elem_child (\"instances\") failed "
"for host %s.",
hostname);
- return (-1);
+ return -1;
}
instance = na_child_get_string(instances, "name");
"na_child_get_string (\"name\") failed "
"for host %s.",
hostname);
- return (-1);
+ return -1;
}
counter_iter = na_child_iterator(na_elem_child(instances, "counters"));
timestamp, interval);
}
- return (0);
+ return 0;
} /* }}} int cna_handle_system_data */
static int cna_setup_system(cfg_system_t *cs) /* {{{ */
{
if (cs == NULL)
- return (EINVAL);
+ return EINVAL;
if (cs->query != NULL)
- return (0);
+ return 0;
cs->query = na_elem_new("perf-object-get-instances");
if (cs->query == NULL) {
ERROR("netapp plugin: na_elem_new failed.");
- return (-1);
+ return -1;
}
na_child_add_string(cs->query, "objectname", "system");
- return (0);
+ return 0;
} /* }}} int cna_setup_system */
static int cna_query_system(host_config_t *host) /* {{{ */
cdtime_t now;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
/* If system statistics were not configured, return without doing anything. */
if (host->cfg_system == NULL)
- return (0);
+ return 0;
now = cdtime();
if ((host->cfg_system->interval.interval +
host->cfg_system->interval.last_read) > now)
- return (0);
+ return 0;
status = cna_setup_system(host->cfg_system);
if (status != 0)
- return (status);
+ return status;
assert(host->cfg_system->query != NULL);
data = na_server_invoke_elem(host->srv, host->cfg_system->query);
"host %s: %s",
host->name, na_results_reason(data));
na_elem_free(data);
- return (-1);
+ return -1;
}
status = cna_handle_system_data(host->name, host->cfg_system, data,
host->cfg_system->interval.last_read = now;
na_elem_free(data);
- return (status);
+ return status;
} /* }}} int cna_query_system */
/*
static int cna_config_bool_to_flag(const oconfig_item_t *ci, /* {{{ */
uint32_t *flags, uint32_t flag) {
if ((ci == NULL) || (flags == NULL))
- return (EINVAL);
+ return EINVAL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) {
WARNING("netapp plugin: The %s option needs exactly one boolean argument.",
ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].value.boolean)
else
*flags &= ~flag;
- return (0);
+ return 0;
} /* }}} int cna_config_bool_to_flag */
/* Handling of the "Interval" option which is allowed in every block. */
status = cf_util_get_cdtime(ci, &tmp);
if (status != 0)
- return (status);
+ return status;
out_interval->interval = tmp;
out_interval->last_read = 0;
- return (0);
+ return 0;
} /* }}} int cna_config_get_interval */
/* Handling of the "GetIO", "GetOps" and "GetLatency" options within a
cfg_volume_perf_t *cfg_volume_perf;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->cfg_volume_perf == NULL) {
cfg_volume_perf = calloc(1, sizeof(*cfg_volume_perf));
if (cfg_volume_perf == NULL)
- return (ENOMEM);
+ return ENOMEM;
/* Set default flags */
cfg_volume_perf->query = NULL;
cfg_volume_perf->il_octets = ignorelist_create(/* invert = */ 1);
if (cfg_volume_perf->il_octets == NULL) {
sfree(cfg_volume_perf);
- return (ENOMEM);
+ return ENOMEM;
}
cfg_volume_perf->il_operations = ignorelist_create(/* invert = */ 1);
if (cfg_volume_perf->il_operations == NULL) {
ignorelist_free(cfg_volume_perf->il_octets);
sfree(cfg_volume_perf);
- return (ENOMEM);
+ return ENOMEM;
}
cfg_volume_perf->il_latency = ignorelist_create(/* invert = */ 1);
ignorelist_free(cfg_volume_perf->il_octets);
ignorelist_free(cfg_volume_perf->il_operations);
sfree(cfg_volume_perf);
- return (ENOMEM);
+ return ENOMEM;
}
host->cfg_volume_perf = cfg_volume_perf;
item->key);
}
- return (0);
+ return 0;
} /* }}} int cna_config_volume_performance */
/* Handling of the "GetCapacity" and "GetSnapshot" options within a
@@ -2456,12 +2458,12 @@ static int cna_config_quota(host_config_t *host, oconfig_item_t *ci) /* {{{ */
cfg_quota_t *cfg_quota;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->cfg_quota == NULL) {
cfg_quota = calloc(1, sizeof(*cfg_quota));
if (cfg_quota == NULL)
- return (ENOMEM);
+ return ENOMEM;
cfg_quota->query = NULL;
host->cfg_quota = cfg_quota;
@@ -2479,7 +2481,7 @@ static int cna_config_quota(host_config_t *host, oconfig_item_t *ci) /* {{{ */
item->key);
}
- return (0);
+ return 0;
} /* }}} int cna_config_quota */
/* Corresponds to a <Disks /> block */
@@ -2487,12 +2489,12 @@ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
cfg_disk_t *cfg_disk;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->cfg_disk == NULL) {
cfg_disk = calloc(1, sizeof(*cfg_disk));
if (cfg_disk == NULL)
- return (ENOMEM);
+ return ENOMEM;
/* Set default flags */
cfg_disk->flags = CFG_DISK_ALL;
@@ -2520,7 +2522,7 @@ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
host->cfg_disk = NULL;
}
- return (0);
+ return 0;
} /* }}} int cna_config_disk */
/* Corresponds to a <WAFL /> block */
@@ -2529,12 +2531,12 @@ static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */
cfg_wafl_t *cfg_wafl;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->cfg_wafl == NULL) {
cfg_wafl = calloc(1, sizeof(*cfg_wafl));
if (cfg_wafl == NULL)
- return (ENOMEM);
+ return ENOMEM;
/* Set default flags */
cfg_wafl->flags = CFG_WAFL_ALL;
host->cfg_wafl = NULL;
}
- return (0);
+ return 0;
} /* }}} int cna_config_wafl */
/*
cfg_volume_usage_t *cfg_volume_usage;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->cfg_volume_usage == NULL) {
cfg_volume_usage = calloc(1, sizeof(*cfg_volume_usage));
if (cfg_volume_usage == NULL)
- return (ENOMEM);
+ return ENOMEM;
/* Set default flags */
cfg_volume_usage->query = NULL;
cfg_volume_usage->il_capacity = ignorelist_create(/* invert = */ 1);
if (cfg_volume_usage->il_capacity == NULL) {
sfree(cfg_volume_usage);
- return (ENOMEM);
+ return ENOMEM;
}
cfg_volume_usage->il_snapshot = ignorelist_create(/* invert = */ 1);
if (cfg_volume_usage->il_snapshot == NULL) {
ignorelist_free(cfg_volume_usage->il_capacity);
sfree(cfg_volume_usage);
- return (ENOMEM);
+ return ENOMEM;
}
host->cfg_volume_usage = cfg_volume_usage;
item->key);
}
- return (0);
+ return 0;
} /* }}} int cna_config_volume_usage */
/* Corresponds to a <SnapVault /> block */
cfg_system_t *cfg_system;
if ((host == NULL) || (ci == NULL))
- return (EINVAL);
+ return EINVAL;
if (host->cfg_system == NULL) {
cfg_system = calloc(1, sizeof(*cfg_system));
if (cfg_system == NULL)
- return (ENOMEM);
+ return ENOMEM;
/* Set default flags */
cfg_system->flags = CFG_SYSTEM_ALL;
host->cfg_system = NULL;
}
- return (0);
+ return 0;
} /* }}} int cna_config_system */
/* Corresponds to a <Host /> block. */
host = calloc(1, sizeof(*host));
if (host == NULL)
- return (NULL);
+ return NULL;
host->name = NULL;
host->protocol = NA_SERVER_TRANSPORT_HTTPS;
host->cfg_snapvault = NULL;
host->cfg_system = NULL;
- return (host);
+ return host;
} /* }}} host_config_t *cna_alloc_host */
static host_config_t *cna_shallow_clone_host(host_config_t *host) /* {{{ */
host_config_t *clone;
if (host == NULL)
- return (NULL);
+ return NULL;
clone = cna_alloc_host();
if (clone == NULL)
- return (NULL);
+ return NULL;
if (host->name != NULL) {
clone->name = strdup(host->name);
clone->interval = host->interval;
- return (clone);
+ return clone;
} /* }}} host_config_t *cna_shallow_clone_host */
static int cna_read(user_data_t *ud);
.data = host, .free_func = (void *)free_host_config,
});
- return (0);
+ return 0;
} /* }}} int cna_register_host */
static int cna_config_host(host_config_t *host, /* {{{ */
WARNING("netapp plugin: \"%s\" needs exactly one string argument. Ignoring "
"host block.",
ci->key);
- return (1);
+ return 1;
}
status = cf_util_get_string(ci, &host->name);
if (status != 0)
- return (1);
+ return 1;
for (int i = 0; i < ci->children_num; ++i) {
item = ci->children + i;
WARNING("netapp plugin: \"Protocol\" needs to be either \"http\" or "
"\"https\". Ignoring host block \"%s\".",
ci->values[0].value.string);
- return (1);
+ return 1;
}
if (!strcasecmp(item->values[0].value.string, "http"))
host->protocol = NA_SERVER_TRANSPORT_HTTP;
if (status != 0)
return status;
- return (0);
+ return 0;
} /* }}} host_config_t *cna_config_host */
/*
int major_version = 1, minor_version = 1;
if (host == NULL)
- return (EINVAL);
+ return EINVAL;
if (host->srv != NULL)
- return (0);
+ return 0;
if (host->vfiler != NULL) /* Request version 1.7 of the ONTAP API */
minor_version = 7;
host->srv = na_server_open(host->host, major_version, minor_version);
if (host->srv == NULL) {
ERROR("netapp plugin: na_server_open (%s) failed.", host->host);
- return (-1);
+ return -1;
}
na_server_set_transport_type(host->srv, host->protocol,
if (!na_server_set_vfiler(host->srv, host->vfiler)) {
ERROR("netapp plugin: Failed to connect to VFiler '%s' on host '%s'.",
host->vfiler, host->host);
- return (-1);
+ return -1;
} else {
INFO("netapp plugin: Connected to VFiler '%s' on host '%s'.",
host->vfiler, host->host);
}
}
- return (0);
+ return 0;
} /* }}} int cna_init_host */
static int cna_init(void) /* {{{ */
return 1;
}
- return (0);
+ return 0;
} /* }}} cna_init */
static int cna_read_internal(host_config_t *host) { /* {{{ */
status = cna_query_wafl(host);
if (status != 0)
- return (status);
+ return status;
status = cna_query_disk(host);
if (status != 0)
- return (status);
+ return status;
status = cna_query_volume_perf(host);
if (status != 0)
- return (status);
+ return status;
status = cna_query_volume_usage(host);
if (status != 0)
- return (status);
+ return status;
status = cna_query_quota(host);
if (status != 0)
- return (status);
+ return status;
status = cna_query_snapvault(host);
if (status != 0)
- return (status);
+ return status;
status = cna_query_system(host);
if (status != 0)
- return (status);
+ return status;
return 0;
} /* }}} int cna_read_internal */
int status;
if ((ud == NULL) || (ud->data == NULL))
- return (-1);
+ return -1;
host = ud->data;
status = cna_init_host(host);
if (status != 0)
- return (status);
+ return status;
status = cna_read_internal(host);
if (status != 0) {
/* Clean up system resources and stuff. */
na_shutdown();
- return (0);
+ return 0;
} /* }}} int cna_shutdown */
void module_register(void) {
diff --git a/src/netlink.c b/src/netlink.c
index ddae5f26062589fb1db4bffa42df7cfc555726f7..3cc1084bba2c8084a61cb14eef6e3f4a21fc72e3 100644 (file)
--- a/src/netlink.c
+++ b/src/netlink.c
@@ -108,13 +108,13 @@ static int add_ignorelist(const char *dev, const char *type, const char *inst) {
entry = calloc(1, sizeof(*entry));
if (entry == NULL)
- return (-1);
+ return -1;
if (strcasecmp(dev, "All") != 0) {
entry->device = strdup(dev);
if (entry->device == NULL) {
sfree(entry);
- return (-1);
+ return -1;
}
}
@@ -122,7 +122,7 @@ static int add_ignorelist(const char *dev, const char *type, const char *inst) {
if (entry->type == NULL) {
sfree(entry->device);
sfree(entry);
- return (-1);
+ return -1;
}
if (inst != NULL) {
@@ -131,14 +131,14 @@ static int add_ignorelist(const char *dev, const char *type, const char *inst) {
sfree(entry->type);
sfree(entry->device);
sfree(entry);
- return (-1);
+ return -1;
}
}
entry->next = ir_ignorelist_head;
ir_ignorelist_head = entry;
- return (0);
+ return 0;
} /* int add_ignorelist */
/*
assert((dev != NULL) && (type != NULL));
if (ir_ignorelist_head == NULL)
- return (ir_ignorelist_invert ? 0 : 1);
+ return ir_ignorelist_invert ? 0 : 1;
for (ir_ignorelist_t *i = ir_ignorelist_head; i != NULL; i = i->next) {
/* i->device == NULL => match all devices */
i->device == NULL ? "(nil)" : i->device, i->type,
i->inst == NULL ? "(nil)" : i->inst);
- return (ir_ignorelist_invert ? 0 : 1);
+ return ir_ignorelist_invert ? 0 : 1;
} /* for i */
- return (ir_ignorelist_invert);
+ return ir_ignorelist_invert;
} /* int check_ignorelist */
static void submit_one(const char *dev, const char *type,
temp = realloc(iflist, (msg->ifi_index + 1) * sizeof(char *));
if (temp == NULL) {
ERROR("netlink plugin: update_iflist: realloc failed.");
- return (-1);
+ return -1;
}
memset(temp + iflist_len, '\0',
iflist[msg->ifi_index] = strdup(dev);
}
- return (0);
+ return 0;
} /* int update_iflist */
static void check_ignorelist_and_submit(const char *dev,
if (kind == NULL) {
ERROR("netlink plugin: qos_filter_cb: kind == NULL");
- return (-1);
+ return -1;
}
{ /* The ID */
new_val = strdup(value);
if (new_val == NULL)
- return (-1);
+ return -1;
fields_num = strsplit(new_val, fields, STATIC_ARRAY_SIZE(fields));
if ((fields_num < 1) || (fields_num > 8)) {
sfree(new_val);
- return (-1);
+ return -1;
}
if ((strcasecmp(key, "Interface") == 0) ||
ERROR("netlink plugin: Invalid number of fields for option "
"`%s'. Got %i, expected 1 or 2.",
key, fields_num);
- return (-1);
+ return -1;
} else {
add_ignorelist(fields[0], key, (fields_num == 2) ? fields[1] : NULL);
status = 0;
sfree(new_val);
- return (status);
+ return status;
} /* int ir_config */
static int ir_init(void) {
nl = mnl_socket_open(NETLINK_ROUTE);
if (nl == NULL) {
ERROR("netlink plugin: ir_init: mnl_socket_open failed.");
- return (-1);
+ return -1;
}
if (mnl_socket_bind(nl, 0, MNL_SOCKET_AUTOPID) < 0) {
ERROR("netlink plugin: ir_init: mnl_socket_bind failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int ir_init */
static int ir_read(void) {
if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {
ERROR("netlink plugin: ir_read: rtnl_wilddump_request failed.");
- return (-1);
+ return -1;
}
ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));
}
if (ret < 0) {
ERROR("netlink plugin: ir_read: mnl_socket_recvfrom failed.");
- return (-1);
+ return -1;
}
/* `link_filter_cb' will update `iflist' which is used here to iterate
} /* for (type_index) */
} /* for (if_index) */
- return (0);
+ return 0;
} /* int ir_read */
static int ir_shutdown(void) {
nl = NULL;
}
- return (0);
+ return 0;
} /* int ir_shutdown */
void module_register(void) {
diff --git a/src/network.c b/src/network.c
index b5f3d4893abcd63d49e249fde0fdbb328bec6096..00c6c756623332e761ac53a4cbcf6e502d072fbf 100644 (file)
--- a/src/network.c
+++ b/src/network.c
/* This is a value we already sent. Don't allow it to be received again in
* order to avoid looping. */
if ((status == 0) && (time_sent >= ((uint64_t)vl->time)))
- return (0);
+ return 0;
- return (1);
+ return 1;
} /* }}} _Bool check_receive_okay */
static _Bool check_send_okay(const value_list_t *vl) /* {{{ */
int status;
if (network_config_forward)
- return (1);
+ return 1;
if (vl->meta == NULL)
- return (1);
+ return 1;
status = meta_data_get_boolean(vl->meta, "network:received", &received);
if (status == -ENOENT)
- return (1);
+ return 1;
else if (status != 0) {
ERROR("network plugin: check_send_okay: meta_data_get_boolean failed "
"with status %i.",
status);
- return (1);
+ return 1;
}
/* By default, only *send* value lists that were not *received* by the
* network plugin. */
- return (!received);
+ return !received;
} /* }}} _Bool check_send_okay */
static _Bool check_notify_received(const notification_t *n) /* {{{ */
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);
+ return (_Bool)ptr->nm_value.nm_boolean;
- return (0);
+ return 0;
} /* }}} _Bool check_notify_received */
static _Bool check_send_notify_okay(const notification_t *n) /* {{{ */
_Bool received = 0;
if (n->meta == NULL)
- return (1);
+ return 1;
received = check_notify_received(n);
/* By default, only *send* value lists that were not *received* by the
* network plugin. */
- return (!received);
+ return !received;
} /* }}} _Bool check_send_notify_okay */
static int network_dispatch_values(value_list_t *vl, /* {{{ */
if ((vl->time == 0) || (strlen(vl->host) == 0) || (strlen(vl->plugin) == 0) ||
(strlen(vl->type) == 0))
- return (-EINVAL);
+ return -EINVAL;
if (!check_receive_okay(vl)) {
#if COLLECT_DEBUG
name);
#endif
stats_values_not_dispatched++;
- return (0);
+ return 0;
}
assert(vl->meta == NULL);
vl->meta = meta_data_create();
if (vl->meta == NULL) {
ERROR("network plugin: meta_data_create failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
status = meta_data_add_boolean(vl->meta, "network:received", 1);
ERROR("network plugin: meta_data_add_boolean failed.");
meta_data_destroy(vl->meta);
vl->meta = NULL;
- return (status);
+ return status;
}
if (username != NULL) {
ERROR("network plugin: meta_data_add_string failed.");
meta_data_destroy(vl->meta);
vl->meta = NULL;
- return (status);
+ return status;
}
}
meta_data_destroy(vl->meta);
vl->meta = NULL;
- return (0);
+ return 0;
} /* }}} int network_dispatch_values */
static int network_dispatch_notification(notification_t *n) /* {{{ */
ERROR("network plugin: plugin_notification_meta_add_boolean failed.");
plugin_notification_meta_free(n->meta);
n->meta = NULL;
- return (status);
+ return status;
}
status = plugin_dispatch_notification(n);
plugin_notification_meta_free(n->meta);
n->meta = NULL;
- return (status);
+ return status;
} /* }}} int network_dispatch_notification */
#if HAVE_GCRYPT_H
* Because you can't know in a library whether another library has
* already initialized the library */
if (gcry_control(GCRYCTL_ANY_INITIALIZATION_P))
- return (0);
+ return 0;
/* http://www.gnupg.org/documentation/manuals/gcrypt/Multi_002dThreading.html
* To ensure thread-safety, it's important to set GCRYCTL_SET_THREAD_CBS
if (err) {
ERROR("network plugin: gcry_control (GCRYCTL_SET_THREAD_CBS) failed: %s",
gcry_strerror(err));
- return (-1);
+ return -1;
}
#endif
if (err) {
ERROR("network plugin: gcry_control (GCRYCTL_INIT_SECMEM) failed: %s",
gcry_strerror(err));
- return (-1);
+ return -1;
}
gcry_control(GCRYCTL_INITIALIZATION_FINISHED);
- return (0);
+ return 0;
} /* }}} int network_init_gcrypt */
static gcry_cipher_hd_t network_get_aes256_cypher(sockent_t *se, /* {{{ */
cyper_ptr = &se->data.server.cypher;
if (username == NULL)
- return (NULL);
+ return NULL;
secret = fbh_get(se->data.server.userdb, username);
if (secret == NULL)
- return (NULL);
+ return NULL;
gcry_md_hash_buffer(GCRY_MD_SHA256, password_hash, secret, strlen(secret));
ERROR("network plugin: gcry_cipher_open returned: %s",
gcry_strerror(err));
*cyper_ptr = NULL;
- return (NULL);
+ return NULL;
}
} else {
gcry_cipher_reset(*cyper_ptr);
gcry_strerror(err));
gcry_cipher_close(*cyper_ptr);
*cyper_ptr = NULL;
- return (NULL);
+ return NULL;
}
err = gcry_cipher_setiv(*cyper_ptr, iv, iv_size);
gcry_strerror(err));
gcry_cipher_close(*cyper_ptr);
*cyper_ptr = NULL;
- return (NULL);
+ return NULL;
}
- return (*cyper_ptr);
+ return *cyper_ptr;
} /* }}} int network_get_aes256_cypher */
#endif /* HAVE_GCRYPT_H */
(num_values * sizeof(uint8_t)) + (num_values * sizeof(value_t));
if (*ret_buffer_len < packet_len)
- return (-1);
+ return -1;
pkg_values_types = malloc(num_values * sizeof(*pkg_values_types));
if (pkg_values_types == NULL) {
ERROR("network plugin: write_part_values: malloc failed.");
- return (-1);
+ return -1;
}
pkg_values = malloc(num_values * sizeof(*pkg_values));
if (pkg_values == NULL) {
free(pkg_values_types);
ERROR("network plugin: write_part_values: malloc failed.");
- return (-1);
+ return -1;
}
pkg_ph.type = htons(TYPE_VALUES);
ERROR("network plugin: write_part_values: "
"Unknown data source type: %i",
ds->ds[i].type);
- return (-1);
+ return -1;
} /* switch (ds->ds[i].type) */
} /* for (num_values) */
free(pkg_values_types);
free(pkg_values);
- return (0);
+ return 0;
} /* int write_part_values */
static int write_part_number(char **ret_buffer, size_t *ret_buffer_len,
packet_len = sizeof(pkg_head) + sizeof(pkg_value);
if (*ret_buffer_len < packet_len)
- return (-1);
+ return -1;
pkg_head.type = htons(type);
pkg_head.length = htons(packet_len);
*ret_buffer = packet_ptr + packet_len;
*ret_buffer_len -= packet_len;
- return (0);
+ return 0;
} /* int write_part_number */
static int write_part_string(char **ret_buffer, size_t *ret_buffer_len,
buffer_len = 2 * sizeof(uint16_t) + str_len + 1;
if (*ret_buffer_len < buffer_len)
- return (-1);
+ return -1;
pkg_type = htons(type);
pkg_length = htons(buffer_len);
*ret_buffer = buffer + buffer_len;
*ret_buffer_len -= buffer_len;
- return (0);
+ return 0;
} /* int write_part_string */
static int parse_part_values(void **ret_buffer, size_t *ret_buffer_len,
NOTICE("network plugin: packet is too short: "
"buffer_len = %zu",
buffer_len);
- return (-1);
+ return -1;
}
memcpy((void *)&tmp16, buffer, sizeof(tmp16));
"Chunk of size %zu expected, "
"but buffer has only %zu bytes left.",
exp_size, buffer_len);
- return (-1);
+ return -1;
}
assert(pkg_numval <= ((buffer_len - 6) / 9));
WARNING("network plugin: parse_part_values: "
"Length and number of values "
"in the packet don't match.");
- return (-1);
+ return -1;
}
pkg_types = calloc(pkg_numval, sizeof(*pkg_types));
sfree(pkg_types);
sfree(pkg_values);
ERROR("network plugin: parse_part_values: calloc failed.");
- return (-1);
+ return -1;
}
memcpy(pkg_types, buffer, pkg_numval * sizeof(*pkg_types));
pkg_types[i]);
sfree(pkg_types);
sfree(pkg_values);
- return (-1);
+ return -1;
} /* switch (pkg_types[i]) */
}
sfree(pkg_types);
- return (0);
+ return 0;
} /* int parse_part_values */
static int parse_part_number(void **ret_buffer, size_t *ret_buffer_len,
"Chunk of size %zu expected, "
"but buffer has only %zu bytes left.",
exp_size, buffer_len);
- return (-1);
+ return -1;
}
memcpy((void *)&tmp16, buffer, sizeof(tmp16));
*ret_buffer = buffer;
*ret_buffer_len = buffer_len - pkg_length;
- return (0);
+ return 0;
} /* int parse_part_number */
static int parse_part_string(void **ret_buffer, size_t *ret_buffer_len,
size_t payload_size;
if (output_len == 0)
- return (EINVAL);
+ return EINVAL;
if (buffer_len < header_size) {
WARNING("network plugin: parse_part_string: "
"Chunk of at least size %zu expected, "
"but buffer has only %zu bytes left.",
header_size, buffer_len);
- return (-1);
+ return -1;
}
memcpy((void *)&tmp16, buffer, sizeof(tmp16));
"Chunk of size %" PRIu16 " received, "
"but buffer has only %zu bytes left.",
pkg_length, buffer_len);
- return (-1);
+ return -1;
}
/* Check that pkg_length is in the valid range */
"Header claims this packet is only %hu "
"bytes long.",
pkg_length);
- return (-1);
+ return -1;
}
/* Check that the package data fits into the output buffer.
"which is too small to hold the received "
"%zu byte string.",
output_len, payload_size);
- return (-1);
+ return -1;
}
/* All sanity checks successfull, let's copy the data over */
WARNING("network plugin: parse_part_string: "
"Received string does not end "
"with a NULL-byte.");
- return (-1);
+ return -1;
}
*ret_buffer = buffer;
*ret_buffer_len = buffer_len - pkg_length;
- return (0);
+ return 0;
} /* int parse_part_string */
/* Forward declaration: parse_part_sign_sha256 and parse_part_encr_aes256 call
/* Check if the buffer has enough data for this structure. */
if (buffer_len <= PART_SIGNATURE_SHA256_SIZE)
- return (-ENOMEM);
+ return -ENOMEM;
/* Read type and length header */
BUFFER_READ(&pss.head.type, sizeof(pss.head.type));
if ((pss_head_length <= PART_SIGNATURE_SHA256_SIZE) ||
(pss_head_length > buffer_len)) {
ERROR("network plugin: HMAC-SHA-256 with invalid length received.");
- return (-1);
+ return -1;
}
if (se->data.server.userdb == NULL) {
*ret_buffer = buffer + pss_head_length;
*ret_buffer_len -= pss_head_length;
- return (0);
+ return 0;
}
/* Copy the hash. */
username_len = pss_head_length - PART_SIGNATURE_SHA256_SIZE;
pss.username = malloc(username_len + 1);
if (pss.username == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
/* Read the username */
BUFFER_READ(pss.username, username_len);
if (secret == NULL) {
ERROR("network plugin: Unknown user: %s", pss.username);
sfree(pss.username);
- return (-ENOENT);
+ return -ENOENT;
}
/* Create a hash device and check the HMAC */
gcry_strerror(err));
sfree(secret);
sfree(pss.username);
- return (-1);
+ return -1;
}
err = gcry_md_setkey(hd, secret, strlen(secret));
gcry_md_close(hd);
sfree(secret);
sfree(pss.username);
- return (-1);
+ return -1;
}
gcry_md_write(hd, buffer + PART_SIGNATURE_SHA256_SIZE,
gcry_md_close(hd);
sfree(secret);
sfree(pss.username);
- return (-1);
+ return -1;
}
memcpy(hash, hash_ptr, sizeof(hash));
*ret_buffer = buffer + buffer_len;
*ret_buffer_len = 0;
- return (0);
+ return 0;
} /* }}} int parse_part_sign_sha256 */
/* #endif HAVE_GCRYPT_H */
buffer_offset = 0;
if (buffer_size <= PART_SIGNATURE_SHA256_SIZE)
- return (-ENOMEM);
+ return -ENOMEM;
BUFFER_READ(&pss.head.type, sizeof(pss.head.type));
BUFFER_READ(&pss.head.length, sizeof(pss.head.length));
part_len = ntohs(pss.head.length);
if ((part_len <= PART_SIGNATURE_SHA256_SIZE) || (part_len > buffer_size))
- return (-EINVAL);
+ return -EINVAL;
if (warning_has_been_printed == 0) {
WARNING("network plugin: Received signed packet, but the network "
*ret_buffer = buffer + buffer_size;
*ret_buffer_size = 0;
- return (0);
+ return 0;
} /* }}} int parse_part_sign_sha256 */
#endif /* !HAVE_GCRYPT_H */
if (buffer_len <= PART_ENCRYPTION_AES256_SIZE) {
NOTICE("network plugin: parse_part_encr_aes256: "
"Discarding short packet.");
- return (-1);
+ return -1;
}
buffer_offset = 0;
if ((part_size <= PART_ENCRYPTION_AES256_SIZE) || (part_size > buffer_len)) {
NOTICE("network plugin: parse_part_encr_aes256: "
"Discarding part with invalid size.");
- return (-1);
+ return -1;
}
/* Read the username */
(username_len > (part_size - (PART_ENCRYPTION_AES256_SIZE + 1)))) {
NOTICE("network plugin: parse_part_encr_aes256: "
"Discarding part with invalid username length.");
- return (-1);
+ return -1;
}
assert(username_len > 0);
pea.username = malloc(username_len + 1);
if (pea.username == NULL)
- return (-ENOMEM);
+ return -ENOMEM;
BUFFER_READ(pea.username, username_len);
pea.username[username_len] = 0;
if (cypher == NULL) {
ERROR("network plugin: Failed to get cypher. Username: %s", pea.username);
sfree(pea.username);
- return (-1);
+ return -1;
}
payload_len = part_size - (PART_ENCRYPTION_AES256_SIZE + username_len);
sfree(pea.username);
ERROR("network plugin: gcry_cipher_decrypt returned: %s. Username: %s",
gcry_strerror(err), pea.username);
- return (-1);
+ return -1;
}
/* Read the hash */
if (memcmp(hash, pea.hash, sizeof(hash)) != 0) {
ERROR("network plugin: Checksum mismatch. Username: %s", pea.username);
sfree(pea.username);
- return (-1);
+ return -1;
}
parse_packet(se, buffer + buffer_offset, payload_len, flags | PP_ENCRYPTED,
sfree(pea.username);
- return (0);
+ return 0;
} /* }}} int parse_part_encr_aes256 */
/* #endif HAVE_GCRYPT_H */
if ((ph_length <= PART_ENCRYPTION_AES256_SIZE) || (ph_length > buffer_size)) {
ERROR("network plugin: AES-256 encrypted part "
"with invalid length received.");
- return (-1);
+ return -1;
}
if (warning_has_been_printed == 0) {
*ret_buffer = (void *)(((char *)*ret_buffer) + ph_length);
*ret_buffer_size -= ph_length;
- return (0);
+ return 0;
} /* }}} int parse_part_encr_aes256 */
#endif /* !HAVE_GCRYPT_H */
WARNING("network plugin: parse_packet: Received truncated "
"packet, try increasing `MaxPacketSize'");
- return (status);
+ return status;
} /* }}} int parse_packet */
static void free_sockent_client(struct sockent_client *sec) /* {{{ */
assert(se->type == SOCKENT_TYPE_CLIENT);
if ((network_config_ttl < 1) || (network_config_ttl > 255))
- return (-1);
+ return -1;
if (ai->ai_family == AF_INET) {
struct sockaddr_in *addr = (struct sockaddr_in *)ai->ai_addr;
char errbuf[1024];
ERROR("network plugin: setsockopt (ipv4-ttl): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
} else if (ai->ai_family == AF_INET6) {
/* Useful example:
@@ -1601,11 +1601,11 @@ static int network_set_ttl(const sockent_t *se, const struct addrinfo *ai) {
char errbuf[1024];
ERROR("network plugin: setsockopt(ipv6-ttl): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
- return (0);
+ return 0;
} /* int network_set_ttl */
static int network_set_interface(const sockent_t *se,
char errbuf[1024];
ERROR("network plugin: setsockopt (ipv4-multicast-if): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
} else if (ai->ai_family == AF_INET6) {
struct sockaddr_in6 *addr = (struct sockaddr_in6 *)ai->ai_addr;
char errbuf[1024];
ERROR("network plugin: setsockopt (ipv6-multicast-if): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
}
char interface_name[IFNAMSIZ];
if (if_indextoname(se->interface, interface_name) == NULL)
- return (-1);
+ return -1;
DEBUG("network plugin: Binding socket to interface %s", interface_name);
char errbuf[1024];
ERROR("network plugin: setsockopt (bind-if): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* #endif HAVE_IF_INDEXTONAME && SO_BINDTODEVICE */
#endif
}
- return (0);
+ return 0;
} /* }}} network_set_interface */
static int network_bind_socket(int fd, const struct addrinfo *ai,
char errbuf[1024];
ERROR("network plugin: setsockopt (reuseaddr): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
DEBUG("fd = %i; calling `bind'", fd);
if (bind(fd, ai->ai_addr, ai->ai_addrlen) == -1) {
char errbuf[1024];
ERROR("bind: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (ai->ai_family == AF_INET) {
char errbuf[1024];
ERROR("network plugin: setsockopt (multicast-loop): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) ==
char errbuf[1024];
ERROR("network plugin: setsockopt (add-membership): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
} else if (ai->ai_family == AF_INET6) {
/* Useful example:
char errbuf[1024];
ERROR("network plugin: setsockopt (ipv6-multicast-loop): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (setsockopt(fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq,
char errbuf[1024];
ERROR("network plugin: setsockopt (ipv6-add-membership): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
}
char interface_name[IFNAMSIZ];
if (if_indextoname(interface_idx, interface_name) == NULL)
- return (-1);
+ return -1;
DEBUG("fd = %i; Binding socket to interface %s", fd, interface_name);
char errbuf[1024];
ERROR("network plugin: setsockopt (bind-if): %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
#endif /* HAVE_IF_INDEXTONAME && SO_BINDTODEVICE */
- return (0);
+ return 0;
} /* int network_bind_socket */
/* Initialize a sockent structure. `type' must be either `SOCKENT_TYPE_CLIENT'
sockent_t *se;
if ((type != SOCKENT_TYPE_CLIENT) && (type != SOCKENT_TYPE_SERVER))
- return (NULL);
+ return NULL;
se = calloc(1, sizeof(*se));
if (se == NULL)
- return (NULL);
+ return NULL;
se->type = type;
se->node = NULL;
#endif
}
- return (se);
+ return se;
} /* }}} sockent_t *sockent_create */
static int sockent_init_crypto(sockent_t *se) /* {{{ */
if (network_init_gcrypt() < 0) {
ERROR("network plugin: Cannot configure client socket with "
"security: Failed to initialize crypto library.");
- return (-1);
+ return -1;
}
if ((se->data.client.username == NULL) ||
ERROR("network plugin: Client socket with "
"security requested, but no "
"credentials are configured.");
- return (-1);
+ return -1;
}
gcry_md_hash_buffer(GCRY_MD_SHA256, se->data.client.password_hash,
se->data.client.password,
(se->data.server.auth_file == NULL)) {
ERROR("network plugin: Server socket with security requested, "
"but no \"AuthFile\" is configured.");
- return (-1);
+ return -1;
}
if (se->data.server.auth_file != NULL) {
if (network_init_gcrypt() < 0) {
ERROR("network plugin: Cannot configure server socket with security: "
"Failed to initialize crypto library.");
- return (-1);
+ return -1;
}
se->data.server.userdb = fbh_create(se->data.server.auth_file);
if (se->data.server.userdb == NULL) {
ERROR("network plugin: Reading password file \"%s\" failed.",
se->data.server.auth_file);
- return (-1);
+ return -1;
}
}
}
#endif /* }}} HAVE_GCRYPT_H */
- return (0);
+ return 0;
} /* }}} int sockent_init_crypto */
static int sockent_client_disconnect(sockent_t *se) /* {{{ */
struct sockent_client *client;
if ((se == NULL) || (se->type != SOCKENT_TYPE_CLIENT))
- return (EINVAL);
+ return EINVAL;
client = &se->data.client;
if (client->fd >= 0) /* connected */
sfree(client->addr);
client->addrlen = 0;
- return (0);
+ return 0;
} /* }}} int sockent_client_disconnect */
static int sockent_client_connect(sockent_t *se) /* {{{ */
cdtime_t now;
if ((se == NULL) || (se->type != SOCKENT_TYPE_CLIENT))
- return (EINVAL);
+ return EINVAL;
client = &se->data.client;
}
if (client->fd >= 0 && !reconnect) /* already connected and not stale*/
- return (0);
+ return 0;
struct addrinfo ai_hints = {.ai_family = AF_UNSPEC,
.ai_flags = AI_ADDRCONFIG,
LOG_ERR, &complaint, "network plugin: getaddrinfo (%s, %s) failed: %s",
(se->node == NULL) ? "(null)" : se->node,
(se->service == NULL) ? "(null)" : se->service, gai_strerror(status));
- return (-1);
+ return -1;
} else {
c_release(LOG_NOTICE, &complaint,
"network plugin: Successfully resolved \"%s\".", se->node);
freeaddrinfo(ai_list);
if (client->fd < 0)
- return (-1);
+ return -1;
if (client->resolve_interval > 0)
client->next_resolve_reconnect = now + client->resolve_interval;
- return (0);
+ return 0;
} /* }}} int sockent_client_connect */
/* Open the file descriptors for a initialized sockent structure. */
const char *service;
if (se == NULL)
- return (-1);
+ return -1;
assert(se->data.server.fd == NULL);
assert(se->data.server.fd_num == 0);
ERROR("network plugin: getaddrinfo (%s, %s) failed: %s",
(se->node == NULL) ? "(null)" : se->node,
(se->service == NULL) ? "(null)" : se->service, gai_strerror(status));
- return (-1);
+ return -1;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
freeaddrinfo(ai_list);
if (se->data.server.fd_num == 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
} /* }}} int sockent_server_listen */
/* Add a sockent to the global list of sockets */
sockent_t *last_ptr;
if (se == NULL)
- return (-1);
+ return -1;
if (se->type == SOCKENT_TYPE_SERVER) {
struct pollfd *tmp;
sizeof(*tmp) * (listen_sockets_num + se->data.server.fd_num));
if (tmp == NULL) {
ERROR("network plugin: realloc failed.");
- return (-1);
+ return -1;
}
listen_sockets_pollfd = tmp;
tmp = listen_sockets_pollfd + listen_sockets_num;
if (listen_sockets == NULL) {
listen_sockets = se;
- return (0);
+ return 0;
}
last_ptr = listen_sockets;
} else /* if (se->type == SOCKENT_TYPE_CLIENT) */
{
if (sending_sockets == NULL) {
sending_sockets = se;
- return (0);
+ return 0;
}
last_ptr = sending_sockets;
}
last_ptr = last_ptr->next;
last_ptr->next = se;
- return (0);
+ return 0;
} /* }}} int sockent_add */
static void *dispatch_thread(void __attribute__((unused)) * arg) /* {{{ */
sfree(ent);
} /* while (42) */
- return (NULL);
+ return NULL;
} /* }}} void *dispatch_thread */
static int network_receive(void) /* {{{ */
pthread_mutex_unlock(&receive_list_lock);
}
- return (status);
+ return status;
} /* }}} int network_receive */
static void *receive_thread(void __attribute__((unused)) * arg) {
- return (network_receive() ? (void *)1 : (void *)0);
+ return network_receive() ? (void *)1 : (void *)0;
} /* void *receive_thread */
static void network_init_buffer(void) {
if (strcmp(vl_def->host, vl->host) != 0) {
if (write_part_string(&buffer, &buffer_size, TYPE_HOST, vl->host,
strlen(vl->host)) != 0)
- return (-1);
+ return -1;
sstrncpy(vl_def->host, vl->host, sizeof(vl_def->host));
}
if (vl_def->time != vl->time) {
if (write_part_number(&buffer, &buffer_size, TYPE_TIME_HR,
(uint64_t)vl->time))
- return (-1);
+ return -1;
vl_def->time = vl->time;
}
if (vl_def->interval != vl->interval) {
if (write_part_number(&buffer, &buffer_size, TYPE_INTERVAL_HR,
(uint64_t)vl->interval))
- return (-1);
+ return -1;
vl_def->interval = vl->interval;
}
if (strcmp(vl_def->plugin, vl->plugin) != 0) {
if (write_part_string(&buffer, &buffer_size, TYPE_PLUGIN, vl->plugin,
strlen(vl->plugin)) != 0)
- return (-1);
+ return -1;
sstrncpy(vl_def->plugin, vl->plugin, sizeof(vl_def->plugin));
}
if (write_part_string(&buffer, &buffer_size, TYPE_PLUGIN_INSTANCE,
vl->plugin_instance,
strlen(vl->plugin_instance)) != 0)
- return (-1);
+ return -1;
sstrncpy(vl_def->plugin_instance, vl->plugin_instance,
sizeof(vl_def->plugin_instance));
}
if (strcmp(vl_def->type, vl->type) != 0) {
if (write_part_string(&buffer, &buffer_size, TYPE_TYPE, vl->type,
strlen(vl->type)) != 0)
- return (-1);
+ return -1;
sstrncpy(vl_def->type, ds->type, sizeof(vl_def->type));
}
if (strcmp(vl_def->type_instance, vl->type_instance) != 0) {
if (write_part_string(&buffer, &buffer_size, TYPE_TYPE_INSTANCE,
vl->type_instance, strlen(vl->type_instance)) != 0)
- return (-1);
+ return -1;
sstrncpy(vl_def->type_instance, vl->type_instance,
sizeof(vl_def->type_instance));
}
if (write_part_values(&buffer, &buffer_size, ds, vl) != 0)
- return (-1);
+ return -1;
- return (buffer - buffer_orig);
+ return buffer - buffer_orig;
} /* }}} int add_to_buffer */
static void flush_buffer(void) {
pthread_mutex_lock(&stats_lock);
stats_values_not_sent++;
pthread_mutex_unlock(&stats_lock);
- return (0);
+ return 0;
}
uc_meta_data_add_unsigned_int(vl, "network:time_sent", (uint64_t)vl->time);
pthread_mutex_unlock(&send_buffer_lock);
- return ((status < 0) ? -1 : 0);
+ return (status < 0) ? -1 : 0;
} /* int network_write */
static int network_config_set_ttl(const oconfig_item_t *ci) /* {{{ */
int tmp = 0;
if (cf_util_get_int(ci, &tmp) != 0)
- return (-1);
+ return -1;
else if ((tmp > 0) && (tmp <= 255))
network_config_ttl = tmp;
else {
WARNING("network plugin: The `TimeToLive' must be between 1 and 255.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int network_config_set_ttl */
static int network_config_set_interface(const oconfig_item_t *ci, /* {{{ */
char if_name[256];
if (cf_util_get_string_buffer(ci, if_name, sizeof(if_name)) != 0)
- return (-1);
+ return -1;
*interface = if_nametoindex(if_name);
- return (0);
+ return 0;
} /* }}} int network_config_set_interface */
static int network_config_set_buffer_size(const oconfig_item_t *ci) /* {{{ */
@@ -2723,16 +2723,16 @@ static int network_config_set_buffer_size(const oconfig_item_t *ci) /* {{{ */
int tmp = 0;
if (cf_util_get_int(ci, &tmp) != 0)
- return (-1);
+ return -1;
else if ((tmp >= 1024) && (tmp <= 65535))
network_config_packet_size = tmp;
else {
WARNING(
"network plugin: The `MaxPacketSize' must be between 1024 and 65535.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int network_config_set_buffer_size */
#if HAVE_GCRYPT_H
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("network plugin: The `SecurityLevel' config option needs exactly "
"one string argument.");
- return (-1);
+ return -1;
}
str = ci->values[0].value.string;
*retval = SECURITY_LEVEL_NONE;
else {
WARNING("network plugin: Unknown security level: %s.", str);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int network_config_set_security_level */
#endif /* HAVE_GCRYPT_H */
ERROR("network plugin: The `%s' config option needs "
"one or two string arguments.",
ci->key);
- return (-1);
+ return -1;
}
se = sockent_create(SOCKENT_TYPE_SERVER);
if (se == NULL) {
ERROR("network plugin: sockent_create failed.");
- return (-1);
+ return -1;
}
se->node = strdup(ci->values[0].value.string);
"requested, but no AuthFile option was given. Cowardly refusing to "
"open this socket!");
sockent_destroy(se);
- return (-1);
+ return -1;
}
#endif /* HAVE_GCRYPT_H */
ERROR("network plugin: network_config_add_listen: sockent_init_crypto() "
"failed.");
sockent_destroy(se);
- return (-1);
+ return -1;
}
status = sockent_server_listen(se);
ERROR("network plugin: network_config_add_listen: sockent_server_listen "
"failed.");
sockent_destroy(se);
- return (-1);
+ return -1;
}
status = sockent_add(se);
if (status != 0) {
ERROR("network plugin: network_config_add_listen: sockent_add failed.");
sockent_destroy(se);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int network_config_add_listen */
static int network_config_add_server(const oconfig_item_t *ci) /* {{{ */
ERROR("network plugin: The `%s' config option needs "
"one or two string arguments.",
ci->key);
- return (-1);
+ return -1;
}
se = sockent_create(SOCKENT_TYPE_CLIENT);
if (se == NULL) {
ERROR("network plugin: sockent_create failed.");
- return (-1);
+ return -1;
}
se->node = strdup(ci->values[0].value.string);
"requested, but no Username or Password option was given. "
"Cowardly refusing to open this socket!");
sockent_destroy(se);
- return (-1);
+ return -1;
}
#endif /* HAVE_GCRYPT_H */
ERROR("network plugin: network_config_add_server: sockent_init_crypto() "
"failed.");
sockent_destroy(se);
- return (-1);
+ return -1;
}
/* No call to sockent_client_connect() here -- it is called from
if (status != 0) {
ERROR("network plugin: network_config_add_server: sockent_add failed.");
sockent_destroy(se);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int network_config_add_server */
static int network_config(oconfig_item_t *ci) /* {{{ */
}
}
- return (0);
+ return 0;
} /* }}} int network_config */
static int network_notification(const notification_t *n,
int status;
if (!check_send_notify_okay(n))
- return (0);
+ return 0;
memset(buffer, 0, sizeof(buffer));
status = write_part_number(&buffer_ptr, &buffer_free, TYPE_TIME_HR,
(uint64_t)n->time);
if (status != 0)
- return (-1);
+ return -1;
status = write_part_number(&buffer_ptr, &buffer_free, TYPE_SEVERITY,
(uint64_t)n->severity);
if (status != 0)
- return (-1);
+ return -1;
if (strlen(n->host) > 0) {
status = write_part_string(&buffer_ptr, &buffer_free, TYPE_HOST, n->host,
strlen(n->host));
if (status != 0)
- return (-1);
+ return -1;
}
if (strlen(n->plugin) > 0) {
status = write_part_string(&buffer_ptr, &buffer_free, TYPE_PLUGIN,
n->plugin, strlen(n->plugin));
if (status != 0)
- return (-1);
+ return -1;
}
if (strlen(n->plugin_instance) > 0) {
status = write_part_string(&buffer_ptr, &buffer_free, TYPE_PLUGIN_INSTANCE,
n->plugin_instance, strlen(n->plugin_instance));
if (status != 0)
- return (-1);
+ return -1;
}
if (strlen(n->type) > 0) {
status = write_part_string(&buffer_ptr, &buffer_free, TYPE_TYPE, n->type,
strlen(n->type));
if (status != 0)
- return (-1);
+ return -1;
}
if (strlen(n->type_instance) > 0) {
status = write_part_string(&buffer_ptr, &buffer_free, TYPE_TYPE_INSTANCE,
n->type_instance, strlen(n->type_instance));
if (status != 0)
- return (-1);
+ return -1;
}
status = write_part_string(&buffer_ptr, &buffer_free, TYPE_MESSAGE,
n->message, strlen(n->message));
if (status != 0)
- return (-1);
+ return -1;
network_send_buffer(buffer, sizeof(buffer) - buffer_free);
- return (0);
+ return 0;
} /* int network_notification */
static int network_shutdown(void) {
plugin_unregister_write("network");
plugin_unregister_shutdown("network");
- return (0);
+ return 0;
} /* int network_shutdown */
static int network_stats_read(void) /* {{{ */
vl.type_instance[0] = 0;
plugin_dispatch_values(&vl);
- return (0);
+ return 0;
} /* }}} int network_stats_read */
static int network_init(void) {
/* Check if we were already initialized. If so, just return - there's
* nothing more to do (for now, that is). */
if (have_init)
- return (0);
+ return 0;
have_init = 1;
if (network_config_stats)
send_buffer = malloc(network_config_packet_size);
if (send_buffer == NULL) {
ERROR("network plugin: malloc failed.");
- return (-1);
+ return -1;
}
network_init_buffer();
/* If no threads need to be started, return here. */
if ((listen_sockets_num == 0) ||
((dispatch_thread_running != 0) && (receive_thread_running != 0)))
- return (0);
+ return 0;
if (dispatch_thread_running == 0) {
int status;
}
}
- return (0);
+ return 0;
} /* int network_init */
/*
cdtime_t now = cdtime();
if ((send_buffer_last_update + timeout) > now) {
pthread_mutex_unlock(&send_buffer_lock);
- return (0);
+ return 0;
}
}
flush_buffer();
}
pthread_mutex_unlock(&send_buffer_lock);
- return (0);
+ return 0;
} /* int network_flush */
void module_register(void) {
diff --git a/src/nfs.c b/src/nfs.c
index 74c6cbc3eeeba203a8df22e0b5fc3a1e79cccec7..6290613323fdfede22acf8ce39bd685b520cb5eb 100644 (file)
--- a/src/nfs.c
+++ b/src/nfs.c
#endif
#if KERNEL_LINUX
-static int nfs_init(void) { return (0); }
+static int nfs_init(void) { return 0; }
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
nfs4_ksp_server = NULL;
if (kc == NULL)
- return (-1);
+ return -1;
for (kstat_t *ksp_chain = kc->kc_chain; ksp_chain != NULL;
ksp_chain = ksp_chain->ks_next) {
nfs4_ksp_client = ksp_chain;
}
- return (0);
+ return 0;
} /* int nfs_init */
#endif
WARNING("nfs plugin: Wrong number of fields for "
"NFSv%i %s statistics. Expected %zu, got %zu.",
nfs_version, instance, proc_names_num, fields_num);
- return (EINVAL);
+ return EINVAL;
}
nfs_submit_fields(nfs_version, instance, fields, fields_num, proc_names);
- return (0);
+ return 0;
}
static int nfs_submit_nfs4_server(const char *instance, char **fields,
fields_num = NFS4_SERVER_MAX_PROC;
suppress_warning = 1;
} else {
- return (EINVAL);
+ return EINVAL;
}
}
nfs4_server41_procedures_names);
}
- return (0);
+ return 0;
}
static int nfs_submit_nfs4_client(const char *instance, char **fields,
suppress_warning = 1;
} else {
- return (EINVAL);
+ return EINVAL;
}
}
nfs4_client41_procedures_names);
}
- return (0);
+ return 0;
}
static void nfs_read_linux(FILE *fh, const char *inst) {
value_t values[proc_names_num];
if (ksp == NULL)
- return (EINVAL);
+ return EINVAL;
ssnprintf(plugin_instance, sizeof(plugin_instance), "v%i%s", nfs_version,
inst);
}
nfs_procedures_submit(plugin_instance, proc_names, values, proc_names_num);
- return (0);
+ return 0;
}
#endif
fclose(fh);
}
- return (0);
+ return 0;
}
/* #endif KERNEL_LINUX */
nfs_read_kstat(nfs4_ksp_server, /* version = */ 4, "server",
nfs4_procedures_names, nfs4_procedures_names_num);
- return (0);
+ return 0;
}
#endif /* HAVE_LIBKSTAT */
diff --git a/src/nginx.c b/src/nginx.c
index 72c036370ba2178a3726c734f34c177716cabdd0..0f1da0aebdfeb522f15182b91255e5b2ebef12ff 100644 (file)
--- a/src/nginx.c
+++ b/src/nginx.c
}
if (len == 0)
- return (len);
+ return len;
memcpy(&nginx_buffer[nginx_buffer_len], buf, len);
nginx_buffer_len += len;
nginx_buffer[nginx_buffer_len] = 0;
- return (len);
+ return len;
}
static int config_set(char **var, const char *value) {
}
if ((*var = strdup(value)) == NULL)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
}
static int config(const char *key, const char *value) {
if (strcasecmp(key, "url") == 0)
- return (config_set(&url, value));
+ return config_set(&url, value);
else if (strcasecmp(key, "user") == 0)
- return (config_set(&user, value));
+ return config_set(&user, value);
else if (strcasecmp(key, "password") == 0)
- return (config_set(&pass, value));
+ return config_set(&pass, value);
else if (strcasecmp(key, "verifypeer") == 0)
- return (config_set(&verify_peer, value));
+ return config_set(&verify_peer, value);
else if (strcasecmp(key, "verifyhost") == 0)
- return (config_set(&verify_host, value));
+ return config_set(&verify_host, value);
else if (strcasecmp(key, "cacert") == 0)
- return (config_set(&cacert, value));
+ return config_set(&cacert, value);
else if (strcasecmp(key, "timeout") == 0)
- return (config_set(&timeout, value));
+ return config_set(&timeout, value);
else
- return (-1);
+ return -1;
} /* int config */
static int init(void) {
if ((curl = curl_easy_init()) == NULL) {
ERROR("nginx plugin: curl_easy_init failed.");
- return (-1);
+ return -1;
}
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
pass == NULL ? "" : pass);
if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
ERROR("nginx plugin: Credentials would have been truncated.");
- return (-1);
+ return -1;
}
curl_easy_setopt(curl, CURLOPT_USERPWD, credentials);
}
#endif
- return (0);
+ return 0;
} /* void init */
static void submit(const char *type, const char *inst, long long value) {
int fields_num;
if (curl == NULL)
- return (-1);
+ return -1;
if (url == NULL)
- return (-1);
+ return -1;
nginx_buffer_len = 0;
if (curl_easy_perform(curl) != CURLE_OK) {
WARNING("nginx plugin: curl_easy_perform failed: %s", nginx_curl_error);
- return (-1);
+ return -1;
}
ptr = nginx_buffer;
nginx_buffer_len = 0;
- return (0);
+ return 0;
} /* int nginx_read */
void module_register(void) {
diff --git a/src/notify_email.c b/src/notify_email.c
index aaa165abdef9b0998ef7211d04b4f125df7af14c..c1ce2f8bbd9cd6fa3568cd3c5274e07215de0029 100644 (file)
--- a/src/notify_email.c
+++ b/src/notify_email.c
if (session == NULL) {
pthread_mutex_unlock(&session_lock);
ERROR("notify_email plugin: cannot create SMTP session");
- return (-1);
+ return -1;
}
smtp_set_monitorcb(session, monitor_cb, NULL, 1);
if (!smtp_auth_set_context(session, authctx)) {
pthread_mutex_unlock(&session_lock);
ERROR("notify_email plugin: cannot set SMTP auth context");
- return (-1);
+ return -1;
}
pthread_mutex_unlock(&session_lock);
- return (0);
+ return 0;
} /* int notify_email_init */
static int notify_email_shutdown(void) {
auth_client_exit();
pthread_mutex_unlock(&session_lock);
- return (0);
+ return 0;
} /* int notify_email_shutdown */
static int notify_email_config(const char *key, const char *value) {
tmp = realloc(recipients, (recipients_len + 1) * sizeof(char *));
if (tmp == NULL) {
ERROR("notify_email: realloc failed.");
- return (-1);
+ return -1;
}
recipients = tmp;
recipients[recipients_len] = strdup(value);
if (recipients[recipients_len] == NULL) {
ERROR("notify_email: strdup failed.");
- return (-1);
+ return -1;
}
recipients_len++;
} else if (0 == strcasecmp(key, "SMTPServer")) {
int port_tmp = atoi(value);
if (port_tmp < 1 || port_tmp > 65535) {
WARNING("notify_email plugin: Invalid SMTP port: %i", port_tmp);
- return (1);
+ return 1;
}
smtp_port = port_tmp;
} else if (0 == strcasecmp(key, "SMTPUser")) {
if (session == NULL) {
/* Initialization failed or we're in the process of shutting down. */
pthread_mutex_unlock(&session_lock);
- return (-1);
+ return -1;
}
if (!(message = smtp_add_message(session))) {
pthread_mutex_unlock(&session_lock);
ERROR("notify_email plugin: cannot set SMTP message");
- return (-1);
+ return -1;
}
smtp_set_reverse_path(message, email_from);
smtp_set_header(message, "To", NULL, NULL);
ERROR("notify_email plugin: SMTP server problem: %s",
smtp_strerror(smtp_errno(), buf, sizeof buf));
pthread_mutex_unlock(&session_lock);
- return (-1);
+ return -1;
} else {
#if COLLECT_DEBUG
const smtp_status_t *status;
}
pthread_mutex_unlock(&session_lock);
- return (0);
+ return 0;
} /* int notify_email_notification */
void module_register(void) {
diff --git a/src/ntpd.c b/src/ntpd.c
index 21b65f5888b3fb30df46c7f7d936422e9c7c7f69..68ac3a75de6eac2883f8a9303a82eee6a11a2436 100644 (file)
--- a/src/ntpd.c
+++ b/src/ntpd.c
if (ntpd_host != NULL)
free(ntpd_host);
if ((ntpd_host = strdup(value)) == NULL)
- return (1);
+ return 1;
} else if (strcasecmp(key, "Port") == 0) {
int port = (int)(atof(value));
if ((port > 0) && (port <= 65535))
else
include_unit_id = 0;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void ntpd_submit(const char *type, const char *type_inst,
int status;
if (sock_descr >= 0)
- return (sock_descr);
+ return sock_descr;
DEBUG("Opening a new socket");
ERROR("ntpd plugin: getaddrinfo (%s, %s): %s", host, port,
(status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(status));
- return (-1);
+ return -1;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
ERROR("ntpd plugin: Unable to connect to server.");
}
- return (sock_descr);
+ return sock_descr;
}
/* For a description of the arguments see `ntpd_do_query' below. */
@@ -396,7 +396,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
ssize_t pkt_padding; /* Padding in this packet */
if ((sd = ntpd_connect()) < 0)
- return (-1);
+ return -1;
items = NULL;
items_num = 0;
@@ -412,7 +412,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
char errbuf[1024];
ERROR("ntpd plugin: gettimeofday failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
time_end.tv_sec++; /* wait for a most one second */
@@ -424,7 +424,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
char errbuf[1024];
ERROR("ntpd plugin: gettimeofday failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (timeval_cmp(time_end, time_now, &time_left) <= 0)
@@ -450,7 +450,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
char errbuf[1024];
ERROR("ntpd plugin: poll failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (status == 0) /* timeout */
@@ -471,7 +471,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
DEBUG("Closing socket #%i", sd);
close(sd);
sock_descr = sd = -1;
- return (-1);
+ return -1;
}
DEBUG("recv'd %i bytes", status);
@@ -513,7 +513,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
if (INFO_ERR(res.err_nitems) != 0) {
ERROR("ntpd plugin: Received error code %i",
(int)INFO_ERR(res.err_nitems));
- return ((int)INFO_ERR(res.err_nitems));
+ return (int)INFO_ERR(res.err_nitems);
}
/* extract number of items in this packet and the size of these items */
@@ -632,7 +632,7 @@ static int ntpd_receive_response(int *res_items, int *res_size, char **res_data,
done = 1;
} /* while (done == 0) */
- return (0);
+ return 0;
} /* int ntpd_receive_response */
/* For a description of the arguments see `ntpd_do_query' below. */
assert(req_size >= 0);
if ((sd = ntpd_connect()) < 0)
- return (-1);
+ return -1;
req.rm_vn_mode = RM_VN_MODE(0, 0, 0);
req.auth_seq = AUTH_SEQ(0, 0);
DEBUG("`swrite' failed. Closing socket #%i", sd);
close(sd);
sock_descr = sd = -1;
- return (status);
+ return status;
}
- return (0);
+ return 0;
}
/*
status = ntpd_send_request(req_code, req_items, req_size, req_data);
if (status != 0)
- return (status);
+ return status;
status = ntpd_receive_response(res_items, res_size, res_data, res_item_size);
- return (status);
+ return status;
}
static double ntpd_read_fp(int32_t val_int) {
val_int = ntohl(val_int);
val_double = ((double)val_int) / FP_FRAC;
- return (val_double);
+ return val_double;
}
static uint32_t
uint32_t addr = ntohl(peer_info->srcadr);
uint32_t refclock_id = (addr >> 8) & 0x00FF;
- return (refclock_id);
+ return refclock_id;
}
static int ntpd_get_name_from_address(char *buffer, size_t buffer_size,
ERROR("ntpd plugin: getnameinfo failed: %s",
(status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(status));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* ntpd_get_name_from_address */
static int ntpd_get_name_refclock(char *buffer, size_t buffer_size,
uint32_t unit_id = ntohl(peer_info->srcadr) & 0x00FF;
if (((size_t)refclock_id) >= refclock_names_num)
- return (ntpd_get_name_from_address(buffer, buffer_size, peer_info,
- /* do_reverse_lookup = */ 0));
+ return ntpd_get_name_from_address(buffer, buffer_size, peer_info, 0);
if (include_unit_id)
ssnprintf(buffer, buffer_size, "%s-%" PRIu32, refclock_names[refclock_id],
else
sstrncpy(buffer, refclock_names[refclock_id], buffer_size);
- return (0);
+ return 0;
} /* int ntpd_get_name_refclock */
static int ntpd_get_name(char *buffer, size_t buffer_size,
uint32_t addr = ntohl(peer_info->srcadr);
if (!peer_info->v6_flag && ((addr & REFCLOCK_MASK) == REFCLOCK_ADDR))
- return (ntpd_get_name_refclock(buffer, buffer_size, peer_info));
+ return ntpd_get_name_refclock(buffer, buffer_size, peer_info);
else
- return (ntpd_get_name_from_address(buffer, buffer_size, peer_info,
- do_reverse_lookups));
+ return ntpd_get_name_from_address(buffer, buffer_size, peer_info,
+ do_reverse_lookups);
} /* int ntpd_addr_to_name */
static int ntpd_read(void) {
if (status != 0) {
ERROR("ntpd plugin: ntpd_do_query (REQ_GET_KERNEL) failed with status %i",
status);
- return (status);
+ return status;
} else if ((ik == NULL) || (ik_num == 0) || (ik_size == 0)) {
ERROR("ntpd plugin: ntpd_do_query returned unexpected data. "
"(ik = %p; ik_num = %i; ik_size = %i)",
(void *)ik, ik_num, ik_size);
- return (-1);
+ return -1;
}
if (ntohs(ik->status) & STA_NANO) {
ERROR(
"ntpd plugin: ntpd_do_query (REQ_PEER_LIST_SUM) failed with status %i",
status);
- return (status);
+ return status;
} else if ((ps == NULL) || (ps_num == 0) || (ps_size == 0)) {
ERROR("ntpd plugin: ntpd_do_query returned unexpected data. "
"(ps = %p; ps_num = %i; ps_size = %i)",
(void *)ps, ps_num, ps_size);
- return (-1);
+ return -1;
}
for (int i = 0; i < ps_num; i++) {
free(ps);
ps = NULL;
- return (0);
+ return 0;
} /* int ntpd_read */
void module_register(void) {
diff --git a/src/numa.c b/src/numa.c
index 01d74e1ecef0aa88a8e72e9b8057f1bea0eab803..6ef3f0909b095e0b1f3b87bd6fb61e4a46418c73 100644 (file)
--- a/src/numa.c
+++ b/src/numa.c
char errbuf[1024];
ERROR("numa plugin: Reading node %i failed: open(%s): %s", node, path,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
success = 0;
}
fclose(fh);
- return (success ? 0 : -1);
+ return success ? 0 : -1;
} /* }}} int numa_read_node */
static int numa_read(void) /* {{{ */
if (max_node < 0) {
WARNING("numa plugin: No NUMA nodes were detected.");
- return (-1);
+ return -1;
}
success = 0;
success++;
}
- return (success ? 0 : -1);
+ return success ? 0 : -1;
} /* }}} int numa_read */
static int numa_init(void) /* {{{ */
char errbuf[1024];
ERROR("numa plugin: stat(%s) failed: %s", path,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
DEBUG("numa plugin: Found %i nodes.", max_node + 1);
- return (0);
+ return 0;
} /* }}} int numa_init */
void module_register(void) {
diff --git a/src/nut.c b/src/nut.c
index 7dadf50eba7ad0f0a4ce2bb6543e0dcab76ba665..2173af9b5fe3c211bce339378bf60dfe934ebce2 100644 (file)
--- a/src/nut.c
+++ b/src/nut.c
ups = calloc(1, sizeof(*ups));
if (ups == NULL) {
ERROR("nut plugin: nut_add_ups: calloc failed.");
- return (1);
+ return 1;
}
status = upscli_splitname(name, &ups->upsname, &ups->hostname, &ups->port);
if (status != 0) {
ERROR("nut plugin: nut_add_ups: upscli_splitname (%s) failed.", name);
free_nut_ups_t(ups);
- return (1);
+ return 1;
}
if (upslist_head == NULL)
last->next = ups;
}
- return (0);
+ return 0;
} /* int nut_add_ups */
static int nut_force_ssl(const char *value) {
WARNING("nut plugin: nut_force_ssl: invalid FORCESSL value "
"found. Defaulting to false.");
}
- return (0);
+ return 0;
} /* int nut_parse_force_ssl */
static int nut_verify_peer(const char *value) {
WARNING("nut plugin: nut_verify_peer: invalid VERIFYPEER value "
"found. Defaulting to false.");
}
- return (0);
+ return 0;
} /* int nut_verify_peer */
static int nut_ca_path(const char *value) {
} else {
ca_path = NULL; // Should alread be set to NULL from initialization
}
- return (0);
+ return 0;
} /* int nut_ca_path */
static int nut_config(const char *key, const char *value) {
if (strcasecmp(key, "UPS") == 0)
- return (nut_add_ups(value));
+ return nut_add_ups(value);
else if (strcasecmp(key, "FORCESSL") == 0)
- return (nut_force_ssl(value));
+ return nut_force_ssl(value);
else if (strcasecmp(key, "VERIFYPEER") == 0)
- return (nut_verify_peer(value));
+ return nut_verify_peer(value);
else if (strcasecmp(key, "CAPATH") == 0)
- return (nut_ca_path(value));
+ return nut_ca_path(value);
else
- return (-1);
+ return -1;
} /* int nut_config */
static void nut_submit(nut_ups_t *ups, const char *type,
if (verify_peer == 1 && ca_path == NULL) {
ERROR("nut plugin: nut_connect: VerifyPeer true but missing "
"CAPath value.");
- return (-1);
+ return -1;
}
if (verify_peer == 1) {
ERROR("nut plugin: nut_connect: upscli_init (%i, %s) failed: %s",
verify_peer, ca_path, upscli_strerror(ups->conn));
upscli_cleanup();
- return (-1);
+ return -1;
}
} /* if (verify_peer == 1) */
ups->hostname, ups->port, upscli_strerror(ups->conn));
sfree(ups->conn);
upscli_cleanup();
- return (-1);
+ return -1;
} /* if (status != 0) */
INFO("nut plugin: Connection to (%s, %i) established.", ups->hostname,
upscli_strerror(ups->conn));
sfree(ups->conn);
upscli_cleanup();
- return (-1);
+ return -1;
} /* if (ssl_status == 1 && verify_peer == 1) */
- return (0);
+ return 0;
#else /* #if HAVE_UPSCLI_INIT */
int status;
ERROR("nut plugin: nut_connect: upscli_connect (%s, %i) failed: %s",
ups->hostname, ups->port, upscli_strerror(ups->conn));
sfree(ups->conn);
- return (-1);
+ return -1;
} /* if (status != 0) */
INFO("nut plugin: Connection to (%s, %i) established.", ups->hostname,
ERROR("nut plugin: nut_connect: upscli_ssl failed: %s",
upscli_strerror(ups->conn));
sfree(ups->conn);
- return (-1);
+ return -1;
} /* if (ssl_status == 1 && verify_peer == 1) */
- return (0);
+ return 0;
#endif
}
ups->conn = malloc(sizeof(*ups->conn));
if (ups->conn == NULL) {
ERROR("nut plugin: malloc failed.");
- return (-1);
+ return -1;
}
status = nut_connect(ups);
#if HAVE_UPSCLI_INIT
upscli_cleanup();
#endif
- return (-1);
+ return -1;
}
while ((status = upscli_list_next(ups->conn, query_num, query, &answer_num,
}
} /* while (upscli_list_next) */
- return (0);
+ return 0;
} /* int nut_read_one */
static int nut_read(void) {
pthread_mutex_unlock(&read_lock);
if (success != 0)
- return (0);
+ return 0;
for (nut_ups_t *ups = upslist_head; ups != NULL; ups = ups->next)
if (nut_read_one(ups) == 0)
read_busy = 0;
pthread_mutex_unlock(&read_lock);
- return ((success != 0) ? 0 : -1);
+ return (success != 0) ? 0 : -1;
} /* int nut_read */
static int nut_shutdown(void) {
upscli_cleanup();
#endif
- return (0);
+ return 0;
} /* int nut_shutdown */
void module_register(void) {
diff --git a/src/olsrd.c b/src/olsrd.c
index 816a70b28dff6419ef4168fb1588838948674056..eccafae253340097671f46772648f0186e65f3d6 100644 (file)
--- a/src/olsrd.c
+++ b/src/olsrd.c
static const char *olsrd_get_node(void) /* {{{ */
{
if (config_node != NULL)
- return (config_node);
- return (OLSRD_DEFAULT_NODE);
+ return config_node;
+ return OLSRD_DEFAULT_NODE;
} /* }}} const char *olsrd_get_node */
static const char *olsrd_get_service(void) /* {{{ */
{
if (config_service != NULL)
- return (config_service);
- return (OLSRD_DEFAULT_SERVICE);
+ return config_service;
+ return OLSRD_DEFAULT_SERVICE;
} /* }}} const char *olsrd_get_service */
static void olsrd_set_node(const char *node) /* {{{ */
buffer[buffer_len] = 0;
}
- return (buffer_len);
+ return buffer_len;
} /* }}} size_t strchomp */
static size_t strtabsplit(char *string, char **fields, size_t size) /* {{{ */
break;
}
- return (i);
+ return i;
} /* }}} size_t strtabsplit */
static FILE *olsrd_connect(void) /* {{{ */
if (ai_return != 0) {
ERROR("olsrd plugin: getaddrinfo (%s, %s) failed: %s", olsrd_get_node(),
olsrd_get_service(), gai_strerror(ai_return));
- return (NULL);
+ return NULL;
}
fh = NULL;
freeaddrinfo(ai_list);
- return (fh);
+ return fh;
} /* }}} FILE *olsrd_connect */
__attribute__((nonnull(2))) static void
static int olsrd_cb_ignore(int lineno, /* {{{ */
size_t fields_num, char **fields) {
- return (0);
+ return 0;
} /* }}} int olsrd_cb_ignore */
static int olsrd_cb_links(int lineno, /* {{{ */
char *endptr;
if (config_want_links == OLSRD_WANT_NOT)
- return (0);
+ return 0;
/* Special handling of the first line. */
if (lineno <= 0) {
nlq_sum = 0.0;
nlq_num = 0;
- return (0);
+ return 0;
}
/* Special handling of the last line. */
olsrd_submit(/* p.-inst = */ "links", /* type = */ "signal_quality",
"average-nlq", nlq);
- return (0);
+ return 0;
}
if (fields_num != 6)
- return (-1);
+ return -1;
links_num++;
}
}
- return (0);
+ return 0;
} /* }}} int olsrd_cb_links */
static int olsrd_cb_routes(int lineno, /* {{{ */
char *endptr;
if (config_want_routes == OLSRD_WANT_NOT)
- return (0);
+ return 0;
/* Special handling of the first line */
if (lineno <= 0) {
etx_sum = 0.0;
etx_num = 0;
- return (0);
+ return 0;
}
/* Special handling after the last line */
olsrd_submit(/* p.-inst = */ "routes", /* type = */ "route_etx", "average",
etx);
- return (0);
+ return 0;
}
if (fields_num != 5)
- return (-1);
+ return -1;
routes_num++;
}
}
- return (0);
+ return 0;
} /* }}} int olsrd_cb_routes */
static int olsrd_cb_topology(int lineno, /* {{{ */
char *endptr;
if (config_want_topology == OLSRD_WANT_NOT)
- return (0);
+ return 0;
/* Special handling of the first line */
if (lineno <= 0) {
lq_num = 0;
links_num = 0;
- return (0);
+ return 0;
}
/* Special handling after the last line */
olsrd_submit(/* p.-inst = */ "topology", /* type = */ "signal_quality",
/* t.-inst = */ "average", lq);
- return (0);
+ return 0;
}
if (fields_num != 5)
- return (-1);
+ return -1;
links_num++;
}
}
- return (0);
+ return 0;
} /* }}} int olsrd_cb_topology */
static int olsrd_read_table(FILE *fh, /* {{{ */
lineno++;
} /* while (fgets) */
- return (0);
+ return 0;
} /* }}} int olsrd_read_table */
static int olsrd_config(const char *key, const char *value) /* {{{ */
olsrd_set_detail(&config_want_topology, value, key);
else {
ERROR("olsrd plugin: Unknown configuration option given: %s", key);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int olsrd_config */
static int olsrd_read(void) /* {{{ */
fh = olsrd_connect();
if (fh == NULL)
- return (-1);
+ return -1;
fputs("\r\n", fh);
fflush(fh);
fclose(fh);
- return (0);
+ return 0;
} /* }}} int olsrd_read */
static int olsrd_shutdown(void) /* {{{ */
sfree(config_node);
sfree(config_service);
- return (0);
+ return 0;
} /* }}} int olsrd_shutdown */
void module_register(void) {
diff --git a/src/onewire.c b/src/onewire.c
index 407e8574c8d5804abdcb04c4e6d09259f7d9dce4..2d594ec9910e30f5e8cae46aaa0e1096b9034f02 100644 (file)
--- a/src/onewire.c
+++ b/src/onewire.c
result->tv_sec = diff / 1000000;
result->tv_usec = diff % 1000000;
- return (diff < 0);
+ return diff < 0;
}
#endif /* COLLECT_DEBUG */
if (regcomp(®ex_direct, regexp_to_match, REG_EXTENDED)) {
ERROR("onewire plugin: Cannot compile regex");
direct_list_element_free(element);
- return (1);
+ return 1;
}
regex_direct_initialized = 1;
DEBUG("onewire plugin: Compiled regex!!");
if (ignorelist_add(sensor_list, value)) {
ERROR("onewire plugin: Cannot add value to ignorelist.");
- return (1);
+ return 1;
}
} else {
DEBUG("onewire plugin: %s is a direct access", value);
temp = strdup(value);
if (temp == NULL) {
ERROR("onewire plugin: strdup failed.");
- return (1);
+ return 1;
}
sfree(device_g);
device_g = temp;
else
ERROR("onewire plugin: Invalid `Interval' setting: %s", value);
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static int cow_read_values(const char *path, const char *name,
ERROR("onewire plugin: OW_get (%s/%s) failed. error = %s;", path,
family_info->features[i].filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
DEBUG("Read onewire device %s as %s", file, buffer);
free(buffer);
} /* for (i = 0; i < features_num; i++) */
- return ((success > 0) ? 0 : -1);
+ return (success > 0) ? 0 : -1;
} /* int cow_read_values */
/* Forward declaration so the recursion below works */
if ((status > 0) && (status < (int)sizeof(subpath)))
cow_read_bus(subpath);
- return (0);
+ return 0;
} /* int cow_read_ds2409 */
static int cow_read_bus(const char *path) {
if (status < 0) {
ERROR("onewire plugin: OW_get (%s) failed. error = %s;", path,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
DEBUG("onewire plugin: OW_get (%s) returned: %s", path, buffer);
} /* while (strtok_r) */
free(buffer);
- return (0);
+ return 0;
} /* int cow_read_bus */
/* ===================================================================================
if (status < 0) {
ERROR("onewire plugin: OW_get (%s) failed. status = %s;", traverse->path,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
DEBUG("onewire plugin: Read onewire device %s as %s", traverse->path,
buffer);
regfree(®ex_direct);
}
- return (0);
+ return 0;
} /* int cow_shutdown */
static int cow_init(void) {
if (device_g == NULL) {
ERROR("onewire plugin: cow_init: No device configured.");
- return (-1);
+ return -1;
}
DEBUG("onewire plugin: about to init device <%s>.", device_g);
if (status != 0) {
ERROR("onewire plugin: OW_init(%s) failed: %s.", device_g,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
plugin_register_complex_read(/* group = */ NULL, "onewire", cow_read,
ow_interval, /* user data = */ NULL);
plugin_register_shutdown("onewire", cow_shutdown);
- return (0);
+ return 0;
} /* int cow_init */
void module_register(void) {
diff --git a/src/openldap.c b/src/openldap.c
index 5269e5f2a2d715cf8ee44527f2434e43be58691a..1156169c41e4c01d66ec23bbbf28e5e787335dc5 100644 (file)
--- a/src/openldap.c
+++ b/src/openldap.c
if (st->state && st->ld) {
DEBUG("openldap plugin: Already connected to %s", st->url);
- return (0);
+ return 0;
}
rc = ldap_initialize(&ld, st->url);
ERROR("openldap plugin: ldap_initialize failed: %s", ldap_err2string(rc));
st->state = 0;
ldap_unbind_ext_s(ld, NULL, NULL);
- return (-1);
+ return -1;
}
st->ld = ld;
ldap_err2string(rc));
st->state = 0;
ldap_unbind_ext_s(st->ld, NULL, NULL);
- return (-1);
+ return -1;
}
}
ldap_err2string(rc));
st->state = 0;
ldap_unbind_ext_s(st->ld, NULL, NULL);
- return (-1);
+ return -1;
} else {
DEBUG("openldap plugin: Successfully connected to %s", st->url);
st->state = 1;
- return (0);
+ return 0;
}
} /* }}} static cldap_init_host */
if ((ud == NULL) || (ud->data == NULL)) {
ERROR("openldap plugin: cldap_read_host: Invalid user data.");
- return (-1);
+ return -1;
}
st = (cldap_t *)ud->data;
status = cldap_init_host(st);
if (status != 0)
- return (-1);
+ return -1;
rc = ldap_search_ext_s(st->ld, "cn=Monitor", LDAP_SCOPE_SUBTREE,
"(|(!(cn=* *))(cn=Database*))", attrs, 0, NULL, NULL,
ldap_msgfree(result);
st->state = 0;
ldap_unbind_ext_s(st->ld, NULL, NULL);
- return (-1);
+ return -1;
}
for (LDAPMessage *e = ldap_first_entry(st->ld, result); e != NULL;
}
ldap_msgfree(result);
- return (0);
+ return 0;
} /* }}} int cldap_read_host */
/* Configuration handling functions {{{
st = calloc(1, sizeof(*st));
if (st == NULL) {
ERROR("openldap plugin: calloc failed.");
- return (-1);
+ return -1;
}
status = cf_util_get_string(ci, &st->name);
if (status != 0) {
sfree(st);
- return (status);
+ return status;
}
st->starttls = 0;
if (status != 0) {
cldap_free(st);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int cldap_config_add */
static int cldap_config(oconfig_item_t *ci) /* {{{ */
child->key);
} /* for (ci->children) */
- return (status);
+ return status;
} /* }}} int cldap_config */
/* }}} End of configuration handling functions */
* ldap_initialize(3) */
int debug_level;
ldap_get_option(NULL, LDAP_OPT_DEBUG_LEVEL, &debug_level);
- return (0);
+ return 0;
} /* }}} int cldap_init */
static int cldap_shutdown(void) /* {{{ */
sfree(databases);
databases_num = 0;
- return (0);
+ return 0;
} /* }}} int cldap_shutdown */
void module_register(void) /* {{{ */
diff --git a/src/openvpn.c b/src/openvpn.c
index 1045d50010d587aa28d5c5ce97c3f50688d85ccc..143a770b031420e5beaa48e1215476ca943d85b4 100644 (file)
--- a/src/openvpn.c
+++ b/src/openvpn.c
break;
}
- return (i);
+ return i;
} /* int openvpn_strsplit */
/* dispatches number of users */
read = 1;
- return (read);
+ return read;
} /* int single_read */
/* for reading status version 1 */
}
if (ferror(fh))
- return (0);
+ return 0;
if (collect_user_count)
numusers_submit(name, name, sum_users);
- return (1);
+ return 1;
} /* int multi1_read */
/* for reading status version 2 */
read = 1;
}
- return (read);
+ return read;
} /* int multi2_read */
/* for reading status version 3 */
read = 1;
}
- return (read);
+ return read;
} /* int multi3_read */
/* for reading status version 4 */
read = 1;
}
- return (read);
+ return read;
} /* int multi4_read */
/* read callback */
read = 0;
if (vpn_num == 0)
- return (0);
+ return 0;
/* call the right read function for every status entry in the list */
for (int i = 0; i < vpn_num; i++) {
read += vpn_read;
}
- return (read ? 0 : -1);
+ return read ? 0 : -1;
} /* int openvpn_read */
static int version_detect(const char *filename) {
/* Sanity checking. We're called from the config handling routine, so
* better play it save. */
if ((filename == NULL) || (*filename == 0))
- return (0);
+ return 0;
fh = fopen(filename, "r");
if (fh == NULL) {
char errbuf[1024];
WARNING("openvpn plugin: Unable to read \"%s\": %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (0);
+ return 0;
}
/* now search for the specific multimode data format */
WARNING("openvpn plugin: unable to detect status version, "
"discarding status file \"%s\".",
value);
- return (1);
+ return 1;
}
status_file = sstrdup(value);
char errbuf[1024];
WARNING("openvpn plugin: sstrdup failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
/* it determines the file name as string starting at location filename + 1
"different one.",
status_name);
sfree(status_file);
- return (1);
+ return 1;
}
}
ERROR("openvpn plugin: malloc failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
sfree(status_file);
- return (1);
+ return 1;
}
temp->file = status_file;
temp->version = status_version;
sfree(vpn_list);
sfree(temp->file);
sfree(temp);
- return (1);
+ return 1;
}
vpn_list = tmp_list;
collect_individual_users = 1;
} /* if (strcasecmp("CollectIndividualUsers", key) == 0) */
else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int openvpn_config */
/* shutdown callback */
sfree(vpn_list);
- return (0);
+ return 0;
} /* int openvpn_shutdown */
static int openvpn_init(void) {
WARNING("OpenVPN plugin: Neither `CollectIndividualUsers', "
"`CollectCompression', nor `CollectUserCount' is true. There's no "
"data left to collect.");
- return (-1);
+ return -1;
}
plugin_register_read("openvpn", openvpn_read);
plugin_register_shutdown("openvpn", openvpn_shutdown);
- return (0);
+ return 0;
} /* int openvpn_init */
void module_register(void) {
diff --git a/src/oracle.c b/src/oracle.c
index cdeebfeffb3152f9503260ce123282b7fcb3dc03..2d98f0aa3d2734fc682e8534ff76d623647f64e3 100644 (file)
--- a/src/oracle.c
+++ b/src/oracle.c
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("oracle plugin: The `Database' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
db = calloc(1, sizeof(*db));
if (db == NULL) {
ERROR("oracle plugin: calloc failed.");
- return (-1);
+ return -1;
}
db->name = NULL;
db->host = NULL;
status = cf_util_get_string(ci, &db->name);
if (status != 0) {
sfree(db);
- return (status);
+ return status;
}
/* Fill the `o_database_t' structure.. */
if (status != 0) {
o_database_free(db);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int o_config_add_database */
static int o_config(oconfig_item_t *ci) /* {{{ */
}
} /* for (ci->children) */
- return (0);
+ return 0;
} /* }}} int o_config */
/* }}} End of configuration handling functions */
int status;
if (oci_env != NULL)
- return (0);
+ return 0;
status = OCIEnvCreate(&oci_env,
/* mode = */ OCI_THREADED,
/* user_data_ptr = */ NULL);
if (status != 0) {
ERROR("oracle plugin: OCIEnvCreate failed with status %i.", status);
- return (-1);
+ return -1;
}
status = OCIHandleAlloc(oci_env, (void *)&oci_error, OCI_HTYPE_ERROR,
ERROR("oracle plugin: OCIHandleAlloc (OCI_HTYPE_ERROR) failed "
"with status %i.",
status);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int o_init */
static int o_read_database_query(o_database_t *db, /* {{{ */
o_report_error("o_read_database_query", db->name, udb_query_get_name(q),
"OCIHandleAlloc", oci_error);
oci_statement = NULL;
- return (-1);
+ return -1;
}
status = OCIStmtPrepare(oci_statement, oci_error, (text *)statement,
"OCIStmtPrepare", oci_error);
OCIHandleFree(oci_statement, OCI_HTYPE_STMT);
oci_statement = NULL;
- return (-1);
+ return -1;
}
udb_query_set_user_data(q, oci_statement);
if (status != OCI_SUCCESS) {
o_report_error("o_read_database_query", db->name, udb_query_get_name(q),
"OCIStmtExecute", oci_error);
- return (-1);
+ return -1;
} /* }}} */
/* Acquire the number of columns returned. */
if (status != OCI_SUCCESS) {
o_report_error("o_read_database_query", db->name, udb_query_get_name(q),
"OCIAttrGet", oci_error);
- return (-1);
+ return -1;
} /* }}} */
column_num = (size_t)param_counter;
if ((ptr) == NULL) { \
FREE_ALL; \
ERROR("oracle plugin: o_read_database_query: calloc failed."); \
- return (-1); \
+ return -1; \
} \
} while (0)
"udb_query_prepare_result failed.",
db->name, udb_query_get_name(q));
FREE_ALL;
- return (-1);
+ return -1;
}
/* Fetch and handle all the rows that matched the query. */
* %s", q->statement); */
FREE_ALL;
- return (0);
+ return 0;
#undef FREE_ALL
#undef ALLOC_OR_FAIL
} /* }}} int o_read_database_query */
if (status != OCI_SUCCESS) {
o_report_error("o_read_database", db->name, NULL, "OCIAttrGet",
oci_error);
- return (-1);
+ return -1;
}
if (server_handle == NULL) {
if (status != OCI_SUCCESS) {
o_report_error("o_read_database", db->name, NULL, "OCIAttrGet",
oci_error);
- return (-1);
+ return -1;
}
}
DEBUG("oracle plugin: OCILogon (%s): db->oci_service_context = %p;",
db->connect_id, db->oci_service_context);
db->oci_service_context = NULL;
- return (-1);
+ return -1;
} else if (status == OCI_SUCCESS_WITH_INFO) {
/* TODO: Print NOTIFY message. */
}
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);
+ return 0;
} /* }}} int o_read_database */
static int o_read(void) /* {{{ */
for (i = 0; i < databases_num; i++)
o_read_database(databases[i]);
- return (0);
+ return 0;
} /* }}} int o_read */
static int o_shutdown(void) /* {{{ */
queries = NULL;
queries_num = 0;
- return (0);
+ return 0;
} /* }}} int o_shutdown */
void module_register(void) /* {{{ */
diff --git a/src/ovs_events.c b/src/ovs_events.c
index d372b87ab2b9e0ff023b3e07abd1d3f18feaae7a..65042343215adb4d31d723a7d36cd4a5a56cd86c 100644 (file)
--- a/src/ovs_events.c
+++ b/src/ovs_events.c
*/
static int ovs_events_ctx_lock() {
pthread_mutex_lock(&ovs_events_ctx.mutex);
- return (1);
+ return 1;
}
/* This function is used only by "OVS_EVENTS_CTX_LOCK" define (see above).
*/
static int ovs_events_ctx_unlock() {
pthread_mutex_unlock(&ovs_events_ctx.mutex);
- return (0);
+ return 0;
}
/* Check if given interface name exists in configuration file. It
*/
static int ovs_events_config_iface_exists(const char *ifname) {
if (ovs_events_ctx.config.ifaces == NULL)
- return (-1);
+ return -1;
/* check if given interface exists */
for (ovs_events_iface_list_t *iface = ovs_events_ctx.config.ifaces; iface;
iface = iface->next)
if (strcmp(ifname, iface->name) == 0)
- return (1);
+ return 1;
- return (0);
+ return 0;
}
/* Get OVS DB select parameter request based on rfc7047,
if (ci->values[j].type != OCONFIG_TYPE_STRING) {
ERROR(OVS_EVENTS_PLUGIN
": given interface name is not a string [idx=%d]", j);
- return (-1);
+ return -1;
}
/* allocate memory for configured interface */
ovs_events_iface_list_t *new_iface = calloc(1, sizeof(*new_iface));
if (new_iface == NULL) {
ERROR(OVS_EVENTS_PLUGIN ": calloc () copy interface name fail");
- return (-1);
+ return -1;
} else {
/* store interface name */
sstrncpy(new_iface->name, ci->values[j].value.string,
new_iface->name);
}
}
- return (0);
+ return 0;
}
/* Parse plugin configuration file and store the config
if (cf_util_get_boolean(child,
&ovs_events_ctx.config.send_notification) != 0) {
ovs_events_config_free();
- return (-1);
+ return -1;
}
} else if (strcasecmp("Address", child->key) == 0) {
if (cf_util_get_string_buffer(
child, ovs_events_ctx.config.ovs_db_node,
sizeof(ovs_events_ctx.config.ovs_db_node)) != 0) {
ovs_events_config_free();
- return (-1);
+ return -1;
}
} else if (strcasecmp("Port", child->key) == 0) {
char *service = NULL;
if (cf_util_get_service(child, &service) != 0) {
ovs_events_config_free();
- return (-1);
+ return -1;
}
strncpy(ovs_events_ctx.config.ovs_db_serv, service,
sizeof(ovs_events_ctx.config.ovs_db_serv));
child, ovs_events_ctx.config.ovs_db_unix,
sizeof(ovs_events_ctx.config.ovs_db_unix)) != 0) {
ovs_events_config_free();
- return (-1);
+ return -1;
}
} else if (strcasecmp("Interfaces", child->key) == 0) {
if (ovs_events_config_get_interfaces(child) != 0) {
ovs_events_config_free();
- return (-1);
+ return -1;
}
} else if (strcasecmp("DispatchValues", child->key) == 0) {
if (cf_util_get_boolean(child, &dispatch_values) != 0) {
ovs_events_config_free();
- return (-1);
+ return -1;
}
} else {
ERROR(OVS_EVENTS_PLUGIN ": option '%s' is not allowed here", child->key);
ovs_events_config_free();
- return (-1);
+ return -1;
}
}
/* Check and warn about invalid configuration */
return plugin_register_complex_read(NULL, OVS_EVENTS_PLUGIN,
ovs_events_plugin_read, 0, NULL);
- return (0);
+ return 0;
}
/* Dispatch OVS interface link status event to collectd */
/* check YAJL type */
if (!YAJL_IS_OBJECT(jobject))
- return (-1);
+ return -1;
/* zero the interface info structure */
memset(ifinfo, 0, sizeof(*ifinfo));
/* try to find external_ids, name and link_state fields */
jexternal_ids = ovs_utils_get_value_by_key(jobject, "external_ids");
if (jexternal_ids == NULL || ifinfo == NULL)
- return (-1);
+ return -1;
/* get iface-id from external_ids field */
jvalue = ovs_utils_get_map_value(jexternal_ids, "iface-id");
jvalue = ovs_utils_get_value_by_key(jobject, "_uuid");
if (jvalue == NULL || !YAJL_IS_ARRAY(jvalue) ||
YAJL_GET_ARRAY(jvalue)->len != 2)
- return (-1);
+ return -1;
juuid = YAJL_GET_ARRAY(jvalue)->values[1];
if (juuid == NULL || !YAJL_IS_STRING(juuid))
- return (-1);
+ return -1;
sstrncpy(ifinfo->uuid, YAJL_GET_STRING(juuid), sizeof(ifinfo->uuid));
/* get interface name */
jvalue = ovs_utils_get_value_by_key(jobject, "name");
if (jvalue == NULL || !YAJL_IS_STRING(jvalue))
- return (-1);
+ return -1;
sstrncpy(ifinfo->name, YAJL_GET_STRING(jvalue), sizeof(ifinfo->name));
/* get OVS DB interface link status */
else if (strcmp(state, "down") == 0)
ifinfo->link_status = DOWN;
}
- return (0);
+ return 0;
}
/* Process OVS DB update table event. It handles link status update event(s)
ovs_events_ctx.ovs_db_select_params,
ovs_events_poll_result_cb) < 0) {
ERROR(OVS_EVENTS_PLUGIN ": get interface info failed");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* Initialize OVS plugin */
OVS_EVENTS_CTX_LOCK { ovs_events_ctx.ovs_db = ovs_db; }
DEBUG(OVS_EVENTS_PLUGIN ": plugin has been initialized");
- return (0);
+ return 0;
ovs_events_failure:
ERROR(OVS_EVENTS_PLUGIN ": plugin initialize failed");
/* release allocated memory */
ovs_events_config_free();
- return (-1);
+ return -1;
}
/* Shutdown OVS plugin */
ovs_events_config_free();
DEBUG(OVS_EVENTS_PLUGIN ": plugin has been destroyed");
- return (0);
+ return 0;
}
/* Register OVS plugin callbacks */
diff --git a/src/ovs_stats.c b/src/ovs_stats.c
index 23b7533c185a0ddeb52d21c800c5ce2351e28b78..31af77c841d9543d8b7f34fa4e86a2baf0f17802 100644 (file)
--- a/src/ovs_stats.c
+++ b/src/ovs_stats.c
}
} else
WARNING("%s: Incorrect data for deleting bridge", plugin_name);
- return (0);
+ return 0;
}
/* Update Bridge. Create bridge ports*/
br = (bridge_list_t *)calloc(1, sizeof(bridge_list_t));
if (!br) {
ERROR("%s: Error allocating memory for bridge", plugin_name);
- return (-1);
+ return -1;
}
char *tmp = YAJL_GET_STRING(br_name);
if (br->name == NULL) {
sfree(br);
pthread_mutex_unlock(&g_stats_lock);
- return (-1);
+ return -1;
}
br->next = g_bridge_list_head;
g_bridge_list_head = br;
}
} else {
ERROR("Incorrect JSON Bridge data");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* Handle JSON with Bridge Table change event */
}
} else {
ERROR("Incorrect JSON Port data");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* Delete port from global port list */
break;
}
}
- return (0);
+ return 0;
}
/* Handle JSON with Port Table change event */
for (size_t i = 0; i < YAJL_GET_ARRAY(stats)->len; i++) {
stat = YAJL_GET_ARRAY(stats)->values[i];
if (!YAJL_IS_ARRAY(stat))
- return (-1);
+ return -1;
counter_name = YAJL_GET_STRING(YAJL_GET_ARRAY(stat)->values[0]);
counter_index = ovs_stats_counter_name_to_type(counter_name);
counter_value = YAJL_GET_INTEGER(YAJL_GET_ARRAY(stat)->values[1]);
port->stats[counter_index] = counter_value;
}
- return (0);
+ return 0;
}
/* Update interface external_ids */
@@ -562,7 +562,7 @@ static int ovs_stats_update_iface_ext_ids(port_list_t *port, yajl_val ext_ids) {
for (size_t i = 0; i < YAJL_GET_ARRAY(ext_ids)->len; i++) {
ext_id = YAJL_GET_ARRAY(ext_ids)->values[i];
if (!YAJL_IS_ARRAY(ext_id))
- return (-1);
+ return -1;
key = YAJL_GET_STRING(YAJL_GET_ARRAY(ext_id)->values[0]);
value = YAJL_GET_STRING(YAJL_GET_ARRAY(ext_id)->values[1]);
if (key && value) {
@@ -573,7 +573,7 @@ static int ovs_stats_update_iface_ext_ids(port_list_t *port, yajl_val ext_ids) {
}
}
- return (0);
+ return 0;
}
/* Get interface statistic and external_ids */
if (iface_name && YAJL_IS_STRING(iface_name)) {
port = ovs_stats_get_port_by_name(YAJL_GET_STRING(iface_name));
if (port == NULL)
- return (0);
+ return 0;
}
/*
* {
}
} else {
ERROR("Incorrect JSON Port data");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* Handle JSON with Interface Table change event */
static int ovs_stats_is_monitored_bridge(const char *br_name) {
/* if no bridges are configured, return true */
if (g_monitored_bridge_list_head == NULL)
- return (1);
+ return 1;
/* check if given bridge exists */
if (ovs_stats_get_bridge(g_monitored_bridge_list_head, br_name) != NULL)
- return (1);
+ return 1;
return 0;
}
if (cf_util_get_string_buffer(child, ovs_stats_cfg.ovs_db_node,
OVS_DB_ADDR_NODE_SIZE) != 0) {
ERROR("%s: parse '%s' option failed", plugin_name, child->key);
- return (-1);
+ return -1;
}
} else if (strcasecmp("Port", child->key) == 0) {
if (cf_util_get_string_buffer(child, ovs_stats_cfg.ovs_db_serv,
OVS_DB_ADDR_SERVICE_SIZE) != 0) {
ERROR("%s: parse '%s' option failed", plugin_name, child->key);
- return (-1);
+ return -1;
}
} else if (strcasecmp("Socket", child->key) == 0) {
if (cf_util_get_string_buffer(child, ovs_stats_cfg.ovs_db_unix,
OVS_DB_ADDR_UNIX_SIZE) != 0) {
ERROR("%s: parse '%s' option failed", plugin_name, child->key);
- return (-1);
+ return -1;
}
} else if (strcasecmp("Bridges", child->key) == 0) {
for (int j = 0; j < child->values_num; j++) {
goto cleanup_fail;
}
}
- return (0);
+ return 0;
cleanup_fail:
ovs_stats_free_bridge_list(g_monitored_bridge_list_head);
- return (-1);
+ return -1;
}
/* Initialize OvS Stats plugin*/
ovs_stats_cfg.ovs_db_serv,
ovs_stats_cfg.ovs_db_unix, &cb)) == NULL) {
ERROR("%s: plugin: failed to connect to OvS DB server", plugin_name);
- return (-1);
+ return -1;
}
int err = pthread_mutex_init(&g_stats_lock, NULL);
if (err < 0) {
ERROR("%s: plugin: failed to initialize cache lock", plugin_name);
ovs_db_destroy(g_ovs_db);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* OvS stats read callback. Read bridge/port information and submit it*/
continue;
}
pthread_mutex_unlock(&g_stats_lock);
- return (0);
+ return 0;
}
/* Shutdown OvS Stats plugin */
ovs_stats_free_port_list(g_port_list_head);
pthread_mutex_unlock(&g_stats_lock);
pthread_mutex_destroy(&g_stats_lock);
- return (0);
+ return 0;
}
/* Register OvS Stats plugin callbacks */
diff --git a/src/perl.c b/src/perl.c
index c79cfd2f93767f60d4fc7f03045f0cb665d7f496..9f61928f79f5120c9f558e809af19336741af2ee 100644 (file)
--- a/src/perl.c
+++ b/src/perl.c
else
status = ssnprintf(buf, buf_len, "%s::%s", base_name, module);
if ((status < 0) || ((unsigned int)status >= buf_len))
- return (NULL);
- return (buf);
+ return NULL;
+ return buf;
} /* char *get_module_name */
/*
if (NULL == get_module_name(module_name, sizeof(module_name), value)) {
log_err("Invalid module name %s", value);
- return (1);
+ return 1;
}
if (0 != init_pi(perl_argc, perl_argv))
diff --git a/src/pf.c b/src/pf.c
index 533dffedeeb83e620f5334aec4c2e402484dd400..82adc53b275d2b10f0a194e586d220121f9fe4a5 100644 (file)
--- a/src/pf.c
+++ b/src/pf.c
char errbuf[1024];
ERROR("pf plugin: Unable to open %s: %s", pf_device,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
status = ioctl(fd, DIOCGETSTATUS, &state);
ERROR("pf plugin: ioctl(DIOCGETSTATUS) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
- return (-1);
+ return -1;
}
close(fd);
if (!state.running) {
WARNING("pf plugin: PF is not running.");
- return (-1);
+ return -1;
}
for (int i = 0; i < PFRES_MAX; i++)
pf_submit("pf_states", "current", (uint32_t)state.states,
/* is gauge = */ 1);
- return (0);
+ return 0;
} /* int pf_read */
void module_register(void) { plugin_register_read("pf", pf_read); }
diff --git a/src/pinba.c b/src/pinba.c
index 97eeb0d6bea50d710458e5a69f2dc7efb0ccebee..57ccc7abc50131f16baed038c873d6f132c924c7 100644 (file)
--- a/src/pinba.c
+++ b/src/pinba.c
ret = (derive_t)(fc->i * factor);
ret += (derive_t)(fc->n / (1000000000 / factor));
- return (ret);
+ return ret;
} /* }}} derive_t float_counter_get */
static void strset(char **str, const char *new) /* {{{ */
/* reset node */
node->mem_peak = NAN;
- return (index + 1);
+ return index + 1;
} /* }}} unsigned int service_statnode_collect */
static void service_statnode_process(pinba_statnode_t *node, /* {{{ */
static int pb_del_socket(pinba_socket_t *s, /* {{{ */
nfds_t index) {
if (index >= s->fd_num)
- return (EINVAL);
+ return EINVAL;
close(s->fd[index].fd);
s->fd[index].fd = -1;
}
s->fd_num--;
- return (0);
+ return 0;
} /* }}} int pb_del_socket */
static int pb_add_socket(pinba_socket_t *s, /* {{{ */
"%i sockets. Please complain to the collectd developers so we can "
"raise the limit.",
PINBA_MAX_SOCKETS);
- return (-1);
+ return -1;
}
fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
char errbuf[1024];
ERROR("pinba plugin: socket(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (0);
+ return 0;
}
tmp = 1;
ERROR("pinba plugin: bind(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
- return (0);
+ return 0;
}
s->fd[s->fd_num].fd = fd;
s->fd[s->fd_num].revents = 0;
s->fd_num++;
- return (0);
+ return 0;
} /* }}} int pb_add_socket */
static pinba_socket_t *pinba_socket_open(const char *node, /* {{{ */
status = getaddrinfo(node, service, &ai_hints, &ai_list);
if (status != 0) {
ERROR("pinba plugin: getaddrinfo(3) failed: %s", gai_strerror(status));
- return (NULL);
+ return NULL;
}
assert(ai_list != NULL);
if (s == NULL) {
freeaddrinfo(ai_list);
ERROR("pinba plugin: calloc failed.");
- return (NULL);
+ return NULL;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
s = NULL;
}
- return (s);
+ return s;
} /* }}} pinba_socket_open */
static void pinba_socket_free(pinba_socket_t *socket) /* {{{ */
request = pinba__request__unpack(NULL, buffer_size, buffer);
if (!request)
- return (-1);
+ return -1;
service_process_request(request);
pinba__request__free_unpacked(request, NULL);
- return (0);
+ return 0;
} /* }}} int pinba_process_stats_packet */
static int pinba_udp_read_callback_fn(int sock) /* {{{ */
WARNING("pinba plugin: recvfrom(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
} else if (status == 0) {
DEBUG("pinba plugin: recvfrom(2) returned unexpected status zero.");
- return (-1);
+ return -1;
} else /* if (status > 0) */
{
assert(((size_t)status) < buffer_size);
status = pinba_process_stats_packet(buffer, buffer_size);
if (status != 0)
DEBUG("pinba plugin: Parsing packet failed.");
- return (status);
+ return status;
}
} /* while (42) */
/* not reached */
assert(23 == 42);
- return (-1);
+ return -1;
} /* }}} void pinba_udp_read_callback_fn */
static int receive_loop(void) /* {{{ */
s = pinba_socket_open(conf_node, conf_service);
if (s == NULL) {
ERROR("pinba plugin: Collector thread is exiting prematurely.");
- return (-1);
+ return -1;
}
while (!collector_thread_do_shutdown) {
ERROR("pinba plugin: poll(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
pinba_socket_free(s);
- return (-1);
+ return -1;
}
for (nfds_t i = 0; i < s->fd_num; i++) {
pinba_socket_free(s);
s = NULL;
- return (0);
+ return 0;
} /* }}} int receive_loop */
static void *collector_thread(void *arg) /* {{{ */
memset(&collector_thread_id, 0, sizeof(collector_thread_id));
collector_thread_running = 0;
pthread_exit(NULL);
- return (NULL);
+ return NULL;
} /* }}} void *collector_thread */
/*
status = cf_util_get_string(ci, &name);
if (status != 0)
- return (status);
+ return status;
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
sfree(server);
sfree(script);
- return (status);
+ return status;
} /* }}} int pinba_config_view */
static int plugin_config(oconfig_item_t *ci) /* {{{ */
pthread_mutex_unlock(&stat_nodes_lock);
- return (0);
+ return 0;
} /* }}} int pinba_config */
static int plugin_init(void) /* {{{ */
}
if (collector_thread_running)
- return (0);
+ return 0;
status = plugin_thread_create(&collector_thread_id,
/* attrs = */ NULL, collector_thread,
char errbuf[1024];
ERROR("pinba plugin: pthread_create(3) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
collector_thread_running = 1;
- return (0);
+ return 0;
} /* }}} */
static int plugin_shutdown(void) /* {{{ */
collector_thread_do_shutdown = 0;
} /* if (collector_thread_running) */
- return (0);
+ return 0;
} /* }}} int plugin_shutdown */
static int plugin_submit(const pinba_statnode_t *res) /* {{{ */
sstrncpy(vl.type_instance, "peak", sizeof(vl.type_instance));
plugin_dispatch_values(&vl);
- return (0);
+ return 0;
} /* }}} int plugin_submit */
static int plugin_read(void) /* {{{ */
diff --git a/src/ping.c b/src/ping.c
index 6d9545f3f02de9c717cb11dcfe9b6e3a532e5941..6e056e4640bdd1caf701654a8127de5915b55adf 100644 (file)
--- a/src/ping.c
+++ b/src/ping.c
} /* }}} ping_max_missed */
} /* }}} for (iter) */
- return (0);
+ return 0;
} /* }}} int ping_dispatch_all */
static void *ping_thread(void *arg) /* {{{ */
ERROR("ping plugin: ping_construct failed.");
ping_thread_error = 1;
pthread_mutex_unlock(&ping_lock);
- return ((void *)-1);
+ return (void *)-1;
}
if (ping_source != NULL)
ERROR("ping plugin: No host could be added to ping object. Giving up.");
ping_thread_error = 1;
pthread_mutex_unlock(&ping_lock);
- return ((void *)-1);
+ return (void *)-1;
}
/* Set up `ts_int' */
pthread_mutex_unlock(&ping_lock);
ping_destroy(pingobj);
- return ((void *)0);
+ return (void *)0;
} /* }}} void *ping_thread */
static int start_thread(void) /* {{{ */
if (ping_thread_loop != 0) {
pthread_mutex_unlock(&ping_lock);
- return (0);
+ return 0;
}
ping_thread_loop = 1;
ping_thread_loop = 0;
ERROR("ping plugin: Starting thread failed.");
pthread_mutex_unlock(&ping_lock);
- return (-1);
+ return -1;
}
pthread_mutex_unlock(&ping_lock);
- return (0);
+ return 0;
} /* }}} int start_thread */
static int stop_thread(void) /* {{{ */
if (ping_thread_loop == 0) {
pthread_mutex_unlock(&ping_lock);
- return (-1);
+ return -1;
}
ping_thread_loop = 0;
ping_thread_error = 0;
pthread_mutex_unlock(&ping_lock);
- return (status);
+ return status;
} /* }}} int stop_thread */
static int ping_init(void) /* {{{ */
{
if (hostlist_head == NULL) {
NOTICE("ping plugin: No hosts have been configured.");
- return (-1);
+ return -1;
}
if (ping_timeout > ping_interval) {
}
#endif
- return (start_thread());
+ return start_thread();
} /* }}} int ping_init */
static int config_set_string(const char *name, /* {{{ */
char errbuf[1024];
ERROR("ping plugin: Setting `%s' to `%s' failed: strdup failed: %s", name,
value, sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
if (*var != NULL)
free(*var);
*var = tmp;
- return (0);
+ return 0;
} /* }}} int config_set_string */
static int ping_config(const char *key, const char *value) /* {{{ */
char errbuf[1024];
ERROR("ping plugin: malloc failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
host = strdup(value);
sfree(hl);
ERROR("ping plugin: strdup failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (1);
+ return 1;
}
hl->host = host;
} else if (strcasecmp(key, "SourceAddress") == 0) {
int status = config_set_string(key, &ping_source, value);
if (status != 0)
- return (status);
+ return status;
}
#ifdef HAVE_OPING_1_3
else if (strcasecmp(key, "Device") == 0) {
int status = config_set_string(key, &ping_device, value);
if (status != 0)
- return (status);
+ return status;
}
#endif
else if (strcasecmp(key, "TTL") == 0) {
ping_data = malloc(size + 1);
if (ping_data == NULL) {
ERROR("ping plugin: malloc failed.");
- return (1);
+ return 1;
}
/* Note: By default oping is using constant string
if (ping_max_missed < 0)
INFO("ping plugin: MaxMissed < 0, disabled re-resolving of hosts");
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int ping_config */
static void submit(const char *host, const char *type, /* {{{ */
start_thread();
- return (-1);
+ return -1;
} /* if (ping_thread_error != 0) */
for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
submit(hl->host, "ping_droprate", droprate);
} /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
- return (0);
+ return 0;
} /* }}} int ping_read */
static int ping_shutdown(void) /* {{{ */
INFO("ping plugin: Shutting down thread.");
if (stop_thread() < 0)
- return (-1);
+ return -1;
hl = hostlist_head;
while (hl != NULL) {
ping_data = NULL;
}
- return (0);
+ return 0;
} /* }}} int ping_shutdown */
void module_register(void) {
diff --git a/src/postgresql.c b/src/postgresql.c
index 3a388a5a3e449ba16e4fbf9594754b393fa27239..d0c0ae1324a457e5aeb706196536878fbea10a11 100644 (file)
--- a/src/postgresql.c
+++ b/src/postgresql.c
@@ -407,7 +407,7 @@ static PGresult *c_psql_exec_query_params(c_psql_database_t *db, udb_query_t *q,
char interval[64];
if ((data == NULL) || (data->params_num == 0))
- return (c_psql_exec_query_noparams(db, q));
+ return c_psql_exec_query_noparams(db, q);
assert(db->max_params_num >= data->params_num);
@@ -438,8 +438,7 @@ static PGresult *c_psql_exec_query_params(c_psql_database_t *db, udb_query_t *q,
}
return PQexecParams(db->conn, udb_query_get_statement(q), data->params_num,
- NULL, (const char *const *)params, NULL, NULL,
- /* return text data */ 0);
+ NULL, (const char *const*)params, NULL, NULL, 0);
} /* c_psql_exec_query_params */
/* db->db_lock must be locked when calling this function */
}
data->params_num++;
- return (0);
+ return 0;
} /* config_query_param_add */
static int config_query_callback(udb_query_t *q, oconfig_item_t *ci) {
log_err("Option not allowed within a Query block: `%s'", ci->key);
- return (-1);
+ return -1;
} /* config_query_callback */
static int config_add_writer(oconfig_item_t *ci, c_psql_writer_t *src_writers,
diff --git a/src/powerdns.c b/src/powerdns.c
index 856210870136a0ae12611fd4ce870036f844eed7..0b08b29870c5532b520818d3f66e9404a5477f68 100644 (file)
--- a/src/powerdns.c
+++ b/src/powerdns.c
sd = socket(PF_UNIX, item->socktype, 0);
if (sd < 0) {
FUNC_ERROR("socket");
- return (-1);
+ return -1;
}
sa_unix.sun_family = AF_UNIX;
if ((status != 0) && (errno != ENOENT)) {
SOCK_ERROR("unlink", sa_unix.sun_path);
close(sd);
- return (-1);
+ return -1;
}
do /* while (0) */
unlink(sa_unix.sun_path);
if (status != 0)
- return (-1);
+ return -1;
assert(buffer_size > 0);
buffer = malloc(buffer_size);
if (buffer == NULL) {
FUNC_ERROR("malloc");
- return (-1);
+ return -1;
}
memcpy(buffer, temp, buffer_size - 1);
*ret_buffer = buffer;
*ret_buffer_size = buffer_size;
- return (0);
+ return 0;
} /* }}} int powerdns_get_data_dgram */
static int powerdns_get_data_stream(list_item_t *item, /* {{{ */
sd = socket(PF_UNIX, item->socktype, 0);
if (sd < 0) {
FUNC_ERROR("socket");
- return (-1);
+ return -1;
}
struct timeval timeout;
if (status != 0) {
FUNC_ERROR("setsockopt");
close(sd);
- return (-1);
+ return -1;
}
status =
if (status != 0) {
SOCK_ERROR("connect", item->sockaddr.sun_path);
close(sd);
- return (-1);
+ return -1;
}
/* strlen + 1, because we need to send the terminating NULL byte, too. */
if (status < 0) {
SOCK_ERROR("send", item->sockaddr.sun_path);
close(sd);
- return (-1);
+ return -1;
}
while (42) {
*ret_buffer_size = buffer_size;
}
- return (status);
+ return status;
} /* }}} int powerdns_get_data_stream */
static int powerdns_get_data(list_item_t *item, char **ret_buffer,
size_t *ret_buffer_size) {
if (item->socktype == SOCK_DGRAM)
- return (powerdns_get_data_dgram(item, ret_buffer, ret_buffer_size));
+ return powerdns_get_data_dgram(item, ret_buffer, ret_buffer_size);
else if (item->socktype == SOCK_STREAM)
- return (powerdns_get_data_stream(item, ret_buffer, ret_buffer_size));
+ return powerdns_get_data_stream(item, ret_buffer, ret_buffer_size);
else {
ERROR("powerdns plugin: Unknown socket type: %i", (int)item->socktype);
- return (-1);
+ return -1;
}
} /* int powerdns_get_data */
item->command = strdup(SERVER_COMMAND);
if (item->command == NULL) {
ERROR("powerdns plugin: strdup failed.");
- return (-1);
+ return -1;
}
status = powerdns_get_data(item, &buffer, &buffer_size);
if (status != 0)
- return (-1);
+ return -1;
if (item->fields_num != 0) {
fields = (const char *const *)item->fields;
sfree(buffer);
- return (0);
+ return 0;
} /* }}} int powerdns_read_server */
/*
int status;
if (li == NULL)
- return (0);
+ return 0;
if (li->fields_num < 1) {
sstrncpy(buffer, RECURSOR_COMMAND, sizeof(buffer));
/* seperator = */ " ");
if (status < 0) {
ERROR("powerdns plugin: strjoin failed.");
- return (-1);
+ return -1;
}
buffer[sizeof(buffer) - 1] = 0;
size_t len = strlen(buffer);
li->command = strdup(buffer);
if (li->command == NULL) {
ERROR("powerdns plugin: strdup failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int powerdns_update_recursor_command */
static int powerdns_read_recursor(list_item_t *item) /* {{{ */
status = powerdns_update_recursor_command(item);
if (status != 0) {
ERROR("powerdns plugin: powerdns_update_recursor_command failed.");
- return (-1);
+ return -1;
}
DEBUG("powerdns plugin: powerdns_read_recursor: item->command = %s;",
status = powerdns_get_data(item, &buffer, &buffer_size);
if (status != 0) {
ERROR("powerdns plugin: powerdns_get_data failed.");
- return (-1);
+ return -1;
}
keys_list = strdup(item->command);
if (keys_list == NULL) {
FUNC_ERROR("strdup");
sfree(buffer);
- return (-1);
+ return -1;
}
key_saveptr = NULL;
sfree(buffer);
sfree(keys_list);
- return (0);
+ return 0;
} /* }}} int powerdns_read_recursor */
static int powerdns_config_add_collect(list_item_t *li, /* {{{ */
if (ci->values_num < 1) {
WARNING("powerdns plugin: The `Collect' option needs "
"at least one argument.");
- return (-1);
+ return -1;
}
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 "
"the `Collect' option.");
- return (-1);
+ return -1;
}
temp =
realloc(li->fields, sizeof(char *) * (li->fields_num + ci->values_num));
if (temp == NULL) {
WARNING("powerdns plugin: realloc failed.");
- return (-1);
+ return -1;
}
li->fields = temp;
/* Invalidate a previously computed command */
sfree(li->command);
- return (0);
+ return 0;
} /* }}} int powerdns_config_add_collect */
static int powerdns_config_add_server(oconfig_item_t *ci) /* {{{ */
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("powerdns plugin: `%s' needs exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
item = calloc(1, sizeof(*item));
if (item == NULL) {
ERROR("powerdns plugin: calloc failed.");
- return (-1);
+ return -1;
}
item->instance = strdup(ci->values[0].value.string);
if (item->instance == NULL) {
ERROR("powerdns plugin: strdup failed.");
sfree(item);
- return (-1);
+ return -1;
}
/*
} else {
/* We must never get here.. */
assert(0);
- return (-1);
+ return -1;
}
status = 0;
if (status != 0) {
sfree(socket_temp);
sfree(item);
- return (-1);
+ return -1;
}
DEBUG("powerdns plugin: Add server: instance = %s;", item->instance);
sfree(socket_temp);
- return (0);
+ return 0;
} /* }}} int powerdns_config_add_server */
static int powerdns_config(oconfig_item_t *ci) /* {{{ */
if (list == NULL) {
ERROR("powerdns plugin: `llist_create' failed.");
- return (-1);
+ return -1;
}
}
} else {
char *temp = strdup(option->values[0].value.string);
if (temp == NULL)
- return (1);
+ return 1;
sfree(local_sockpath);
local_sockpath = temp;
}
}
} /* for (i = 0; i < ci->children_num; i++) */
- return (0);
+ return 0;
} /* }}} int powerdns_config */
static int powerdns_read(void) {
item->func(item);
}
- return (0);
+ return 0;
} /* static int powerdns_read */
static int powerdns_shutdown(void) {
if (list == NULL)
- return (0);
+ return 0;
for (llentry_t *e = llist_head(list); e != NULL; e = e->next) {
list_item_t *item = (list_item_t *)e->value;
llist_destroy(list);
list = NULL;
- return (0);
+ return 0;
} /* static int powerdns_shutdown */
void module_register(void) {
diff --git a/src/processes.c b/src/processes.c
index 6e472e600f4bb9c6a260461f206c76e7e6672f5b..82a485900537e891336ac5185c67cd951ed33d28 100644 (file)
--- a/src/processes.c
+++ b/src/processes.c
new = calloc(1, sizeof(*new));
if (new == NULL) {
ERROR("processes plugin: ps_list_register: calloc failed.");
- return (NULL);
+ return NULL;
}
sstrncpy(new->name, name, sizeof(new->name));
if (new->re == NULL) {
ERROR("processes plugin: ps_list_register: malloc failed.");
sfree(new);
- return (NULL);
+ return NULL;
}
status = regcomp(new->re, regexp, REG_EXTENDED | REG_NOSUB);
regexp);
sfree(new->re);
sfree(new);
- return (NULL);
+ return NULL;
}
}
#else
"has been disabled at compile time.",
regexp);
sfree(new);
- return (NULL);
+ return NULL;
}
#endif
sfree(new->re);
#endif
sfree(new);
- return (NULL);
+ return NULL;
}
if (ptr->next == NULL)
else
ptr->next = new;
- return (new);
+ return new;
} /* void ps_list_register */
/* try to match name against entry, returns 1 if success */
/* pmatch = */ NULL,
/* eflags = */ 0);
if (status == 0)
- return (1);
+ return 1;
} else
#endif
if (strcmp(ps->name, name) == 0)
- return (1);
+ return 1;
- return (0);
+ return 0;
} /* int ps_list_match */
static void ps_update_counter(derive_t *group_counter, derive_t *curr_counter,
}
}
- return (0);
+ return 0;
}
static int ps_init(void) {
ERROR("host_processor_sets failed: %s\n", mach_error_string(status));
pset_list = NULL;
pset_list_len = 0;
- return (-1);
+ return -1;
}
/* #endif HAVE_THREAD_INFO */
pagesize = getpagesize();
#endif /* HAVE_PROCINFO_H */
- return (0);
+ return 0;
} /* int ps_init */
/* submit global state (e.g.: qty of zombies, running, etc..) */
if ((dh = opendir(dirname)) == NULL) {
DEBUG("Failed to open directory `%s'", dirname);
- return (-1);
+ return -1;
}
while ((ent = readdir(dh)) != NULL) {
ps->cswitch_vol = cswitch_vol;
ps->cswitch_invol = cswitch_invol;
- return (0);
+ return 0;
} /* int *ps_read_tasks_status */
/* Read data from /proc/pid/status */
ssnprintf(filename, sizeof(filename), "/proc/%li/status", pid);
if ((fh = fopen(filename, "r")) == NULL)
- return (-1);
+ return -1;
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
unsigned long tmp;
if (threads != 0)
ps->num_lwp = threads;
- return (0);
+ return 0;
} /* int *ps_read_status */
static int ps_read_io(process_entry_t *ps) {
ssnprintf(filename, sizeof(filename), "/proc/%li/io", ps->id);
if ((fh = fopen(filename, "r")) == NULL) {
DEBUG("ps_read_io: Failed to open file `%s'", filename);
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
char errbuf[1024];
WARNING("processes: fclose: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
}
- return (0);
+ return 0;
} /* int ps_read_io (...) */
static int ps_count_fd(int pid) {
if ((dh = opendir(dirname)) == NULL) {
DEBUG("Failed to open directory `%s'", dirname);
- return (-1);
+ return -1;
}
while ((ent = readdir(dh)) != NULL) {
if (!isdigit((int)ent->d_name[0]))
}
closedir(dh);
- return ((count >= 1) ? count : 1);
+ return (count >= 1) ? count : 1;
} /* int ps_count_fd (pid) */
static void ps_fill_details(const procstat_t *ps, process_entry_t *entry) {
status = read_file_contents(filename, buffer, sizeof(buffer) - 1);
if (status <= 0)
- return (-1);
+ return -1;
buffer_len = (size_t)status;
buffer[buffer_len] = 0;
if (name_start_pos >= name_end_pos) {
ERROR("processes plugin: name_start_pos = %zu >= name_end_pos = %zu",
name_start_pos, name_end_pos);
- return (-1);
+ return -1;
}
name_len = (name_end_pos - name_start_pos) - 1;
sstrncpy(ps->name, &buffer[name_start_pos + 1], name_len + 1);
if ((buffer_len - name_end_pos) < 2)
- return (-1);
+ return -1;
buffer_ptr = &buffer[name_end_pos + 2];
fields_len = strsplit(buffer_ptr, fields, STATIC_ARRAY_SIZE(fields));
DEBUG("processes plugin: ps_read_process (pid = %li):"
" `%s' has only %i fields..",
pid, filename, fields_len);
- return (-1);
+ return -1;
}
*state = fields[0][0];
DEBUG("processes plugin: This is only a zombie: pid = %li; "
"name = %s;",
pid, ps->name);
- return (0);
+ return 0;
}
cpu_user_counter = atoll(fields[11]);
ps->cswitch_invol = -1;
/* success */
- return (0);
+ return 0;
} /* int ps_read_process (...) */
static char *ps_get_cmdline(long pid, char *name, char *buf, size_t buf_len) {
char errbuf[1024];
ERROR("processes plugin: fopen (/proc/stat) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), proc_stat) != NULL) {
fclose(proc_stat);
if (!value_valid)
- return (-1);
+ return -1;
ps_submit_fork_rate(value.derive);
- return (0);
+ return 0;
}
#endif /*KERNEL_LINUX */
"while reading \"%s\": "
"Returned %zd but expected %zu.",
path, status, buffer_size);
- return (NULL);
+ return NULL;
}
info.pr_psargs[sizeof(info.pr_psargs) - 1] = 0;
sstrncpy(buffer, info.pr_psargs, buffer_size);
- return (buffer);
+ return buffer;
} /* }}} int ps_get_cmdline */
/*
sfree(myStatus);
sfree(myInfo);
sfree(myUsage);
- return (0);
+ return 0;
} else {
ps->num_proc = 1;
ps->num_lwp = myInfo->pr_nlwp;
sfree(myInfo);
sfree(myUsage);
- return (0);
+ return 0;
}
/*
derive_t result = 0;
if (kc == NULL)
- return (-1);
+ return -1;
for (kstat_t *ksp_chain = kc->kc_chain; ksp_chain != NULL;
ksp_chain = ksp_chain->ks_next) {
}
ps_submit_fork_rate(result);
- return (0);
+ return 0;
}
#endif /* KERNEL_SOLARIS */
mib[2] = KERN_PROC_PID;
if (pid_for_task(t, pid) != KERN_SUCCESS)
- return (-1);
+ return -1;
mib[3] = *pid;
kp_size = sizeof(kp);
if (sysctl(mib, 4, &kp, &kp_size, NULL, 0) != 0)
- return (-1);
+ return -1;
if (name_max_len > (MAXCOMLEN + 1))
name_max_len = MAXCOMLEN + 1;
* `top' does it, because it is a lot of work and only used when
* debugging. -octo */
- return (0);
+ return 0;
}
#endif /* HAVE_THREAD_INFO */
/* ------- end of additional functions for KERNEL_LINUX/HAVE_THREAD_INFO -------
if ((proc = opendir("/proc")) == NULL) {
char errbuf[1024];
ERROR("Cannot open `/proc': %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while ((ent = readdir(proc)) != NULL) {
kd = kvm_openfiles(NULL, "/dev/null", NULL, 0, errbuf);
if (kd == NULL) {
ERROR("processes plugin: Cannot open kvm interface: %s", errbuf);
- return (0);
+ return 0;
}
/* Get the list of processes. */
ERROR("processes plugin: Cannot get kvm processes list: %s",
kvm_geterr(kd));
kvm_close(kd);
- return (0);
+ return 0;
}
/* Iterate through the processes in kinfo_proc */
kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
if (kd == NULL) {
ERROR("processes plugin: Cannot open kvm interface: %s", errbuf);
- return (0);
+ return 0;
}
/* Get the list of processes. */
ERROR("processes plugin: Cannot get kvm processes list: %s",
kvm_geterr(kd));
kvm_close(kd);
- return (0);
+ return 0;
}
/* Iterate through the processes in kinfo_proc */
proc = opendir("/proc");
if (proc == NULL)
- return (-1);
+ return -1;
while ((ent = readdir(proc)) != NULL) {
long pid;
want_init = 0;
- return (0);
+ return 0;
} /* int ps_read */
void module_register(void) {
diff --git a/src/protocols.c b/src/protocols.c
index 12fbf45f70dc7d3e8c5fb046de7fb057ab882bf3..32e98243d9c2f54f312dba8c866adb93c0d58b68 100644 (file)
--- a/src/protocols.c
+++ b/src/protocols.c
if (fh == NULL) {
ERROR("protocols plugin: fopen (%s) failed: %s.", path,
sstrerror(errno, key_buffer, sizeof(key_buffer)));
- return (-1);
+ return -1;
}
status = -1;
fclose(fh);
- return (status);
+ return status;
} /* int read_file */
static int protocols_read(void) {
success++;
if (success == 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
} /* int protocols_read */
static int protocols_config(const char *key, const char *value) {
invert = 0;
ignorelist_set_invert(values_list, invert);
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int protocols_config */
void module_register(void) {
diff --git a/src/python.c b/src/python.c
index c6ee5544c47dfb0d1be423de1b232275731e898f..b106e45cbb77e74df010716a455ed619cf3aa377 100644 (file)
--- a/src/python.c
+++ b/src/python.c
static PyObject *cpy_register_notification(PyObject *self, PyObject *args,
PyObject *kwds) {
return cpy_register_generic_userdata((void *)plugin_register_notification,
- (void *)cpy_notification_callback, args,
- kwds);
+ (void *)cpy_notification_callback,
+ args, kwds);
}
static PyObject *cpy_register_flush(PyObject *self, PyObject *args,
}
static PyObject *cpy_unregister_write(PyObject *self, PyObject *arg) {
- return cpy_unregister_generic_userdata(plugin_unregister_write, arg, "write");
+ return cpy_unregister_generic_userdata(plugin_unregister_write, arg,
+ "write");
}
static PyObject *cpy_unregister_notification(PyObject *self, PyObject *arg) {
}
static PyObject *cpy_unregister_flush(PyObject *self, PyObject *arg) {
- return cpy_unregister_generic_userdata(plugin_unregister_flush, arg, "flush");
+ return cpy_unregister_generic_userdata(plugin_unregister_flush, arg,
+ "flush");
}
static PyObject *cpy_unregister_shutdown(PyObject *self, PyObject *arg) {
status = 1;
}
}
- return (status);
+ return status;
}
void module_register(void) {
diff --git a/src/redis.c b/src/redis.c
index 40a311d135df632dc1a6c02d341dda10e25901f4..05225b5bfb2e78ee0aab6ab14feb6e9dd3c36148 100644 (file)
--- a/src/redis.c
+++ b/src/redis.c
if (rn_ptr != NULL) {
ERROR("redis plugin: A node with the name `%s' already exists.", rn->name);
- return (-1);
+ return -1;
}
rn_copy = malloc(sizeof(*rn_copy));
if (rn_copy == NULL) {
ERROR("redis plugin: malloc failed adding redis_node to the tree.");
- return (-1);
+ return -1;
}
memcpy(rn_copy, rn, sizeof(*rn_copy));
rn_ptr->next = rn_copy;
}
- return (0);
+ return 0;
} /* }}} */
static redis_query_t *redis_config_query(oconfig_item_t *ci) /* {{{ */
status = cf_util_get_string_buffer(ci, rn.name, sizeof(rn.name));
if (status != 0)
- return (status);
+ return status;
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *option = ci->children + i;
}
if (status != 0)
- return (status);
+ return status;
- return (redis_node_add(&rn));
+ return redis_node_add(&rn);
} /* }}} int redis_config_node */
static int redis_config(oconfig_item_t *ci) /* {{{ */
if (nodes_head == NULL) {
ERROR("redis plugin: No valid node configuration could be found.");
- return (ENOENT);
+ return ENOENT;
}
- return (0);
+ return 0;
} /* }}} */
__attribute__((nonnull(2))) static void
if (nodes_head == NULL)
redis_node_add(&rn);
- return (0);
+ return 0;
} /* }}} int redis_init */
static int redis_handle_info(char *node, char const *info_line,
if (parse_value(buf, &val, ds_type) == -1) {
WARNING("redis plugin: Unable to parse field `%s'.", field_name);
- return (-1);
+ return -1;
}
redis_submit(node, type, type_instance, val);
- return (0);
+ return 0;
}
- return (-1);
+ return -1;
} /* }}} int redis_handle_info */
ds = plugin_get_ds(rq->type);
if (!ds) {
ERROR("redis plugin: DataSet `%s' not defined.", rq->type);
- return (-1);
+ return -1;
}
if (ds->ds_num != 1) {
ERROR("redis plugin: DS `%s' has too many types.", rq->type);
- return (-1);
+ return -1;
}
if ((rr = redisCommand(rh, rq->query)) == NULL) {
WARNING("redis plugin: unable to carry out query `%s'.", rq->query);
- return (-1);
+ return -1;
}
switch (rr->type) {
if (parse_value(rr->str, &val, ds->ds[0].type) == -1) {
WARNING("redis plugin: Unable to parse field `%s'.", rq->type);
freeReplyObject(rr);
- return (-1);
+ return -1;
}
break;
default:
WARNING("redis plugin: Cannot coerce redis type.");
freeReplyObject(rr);
- return (-1);
+ return -1;
}
redis_submit(rn->name, rq->type,
if (parse_value(buf, &val, DS_TYPE_GAUGE) != 0) {
WARNING("redis plugin: Unable to parse field `%s'.", field_name);
- return (-1);
+ return -1;
}
ssnprintf(db_id, sizeof(db_id), "%d", db);
redis_submit(node, "records", db_id, val);
}
- return (0);
+ return 0;
} /* }}} int redis_db_stats */
diff --git a/src/routeros.c b/src/routeros.c
index 5c978dccfa6f93aa1f75d1efb4bf326a6c668e05..ba92b0b213d372ca4e84d1123f869f7c2bc7a2f0 100644 (file)
--- a/src/routeros.c
+++ b/src/routeros.c
const ros_interface_t *i,
void *user_data) {
if ((i == NULL) || (user_data == NULL))
- return (EINVAL);
+ return EINVAL;
submit_interface(user_data, i);
- return (0);
+ return 0;
} /* }}} int handle_interface */
static void cr_submit_gauge(cr_data_t *rd, const char *type, /* {{{ */
const ros_registration_table_t *r,
void *user_data) {
if ((r == NULL) || (user_data == NULL))
- return (EINVAL);
+ return EINVAL;
submit_regtable(user_data, r);
- return (0);
+ return 0;
} /* }}} int handle_regtable */
#if ROS_VERSION >= ROS_VERSION_ENCODE(1, 1, 0)
cr_data_t *rd;
if ((r == NULL) || (user_data == NULL))
- return (EINVAL);
+ return EINVAL;
rd = user_data;
if (rd->collect_cpu_load)
cr_submit_gauge(rd, "gauge", "bad_blocks", (gauge_t)r->bad_blocks);
}
- return (0);
+ return 0;
} /* }}} int handle_system_resource */
#endif
cr_data_t *rd;
if (user_data == NULL)
- return (EINVAL);
+ return EINVAL;
rd = user_data->data;
if (rd == NULL)
- return (EINVAL);
+ return EINVAL;
if (rd->connection == NULL) {
rd->connection =
char errbuf[128];
ERROR("routeros plugin: ros_connect failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
assert(rd->connection != NULL);
sstrerror(status, errbuf, sizeof(errbuf)));
ros_disconnect(rd->connection);
rd->connection = NULL;
- return (-1);
+ return -1;
}
}
sstrerror(status, errbuf, sizeof(errbuf)));
ros_disconnect(rd->connection);
rd->connection = NULL;
- return (-1);
+ return -1;
}
}
sstrerror(status, errbuf, sizeof(errbuf)));
ros_disconnect(rd->connection);
rd->connection = NULL;
- return (-1);
+ return -1;
}
}
#endif
- return (0);
+ return 0;
} /* }}} int cr_read */
static void cr_free_data(cr_data_t *ptr) /* {{{ */
router_data = calloc(1, sizeof(*router_data));
if (router_data == NULL)
- return (-1);
+ return -1;
router_data->connection = NULL;
router_data->node = NULL;
router_data->service = NULL;
if (status != 0)
cr_free_data(router_data);
- return (status);
+ return status;
} /* }}} int cr_config_router */
static int cr_config(oconfig_item_t *ci) {
}
}
- return (0);
+ return 0;
} /* }}} int cr_config */
void module_register(void) {
diff --git a/src/rrdcached.c b/src/rrdcached.c
index 5cf17c1efa6281e94df9c7afbbf2acc9f56fbd76..4efb1f0cdc0b480bca0ce33ff641711fdb807081 100644 (file)
--- a/src/rrdcached.c
+++ b/src/rrdcached.c
t = CDTIME_T_TO_TIME_T(vl->time);
status = ssnprintf(buffer, buffer_len, "%lu", (unsigned long)t);
if ((status < 1) || (status >= buffer_len))
- return (-1);
+ return -1;
offset = status;
for (size_t i = 0; i < ds->ds_num; i++) {
(ds->ds[i].type != DS_TYPE_GAUGE) &&
(ds->ds[i].type != DS_TYPE_DERIVE) &&
(ds->ds[i].type != DS_TYPE_ABSOLUTE))
- return (-1);
+ return -1;
if (ds->ds[i].type == DS_TYPE_COUNTER) {
status = ssnprintf(buffer + offset, buffer_len - offset, ":%llu",
}
if ((status < 1) || (status >= (buffer_len - offset)))
- return (-1);
+ return -1;
offset += status;
} /* for ds->ds_num */
- return (0);
+ return 0;
} /* int value_list_to_string */
static int value_list_to_filename(char *buffer, size_t buffer_size,
size_t datadir_len = strlen(datadir) + 1;
if (datadir_len >= buffer_size)
- return (ENOMEM);
+ return ENOMEM;
sstrncpy(buffer, datadir, buffer_size);
buffer[datadir_len - 1] = '/';
status = FORMAT_VL(buffer, buffer_size, vl);
if (status != 0)
- return (status);
+ return status;
len = strlen(buffer);
assert(len < buffer_size);
buffer_size -= len;
if (buffer_size <= sizeof(suffix))
- return (ENOMEM);
+ return ENOMEM;
memcpy(buffer, suffix, sizeof(suffix));
- return (0);
+ return 0;
} /* int value_list_to_filename */
static int rc_config_get_int_positive(oconfig_item_t const *ci, int *ret) {
status = cf_util_get_int(ci, &tmp);
if (status != 0)
- return (status);
+ return status;
if (tmp < 0)
- return (EINVAL);
+ return EINVAL;
*ret = tmp;
- return (0);
+ return 0;
} /* int rc_config_get_int_positive */
static int rc_config_get_xff(oconfig_item_t const *ci, double *ret) {
ERROR("rrdcached plugin: The \"%s\" needs exactly one numeric argument "
"in the range [0.0, 1.0)",
ci->key);
- return (EINVAL);
+ return EINVAL;
}
value = ci->values[0].value.number;
if ((value >= 0.0) && (value < 1.0)) {
*ret = value;
- return (0);
+ return 0;
}
ERROR("rrdcached plugin: The \"%s\" needs exactly one numeric argument "
"in the range [0.0, 1.0)",
ci->key);
- return (EINVAL);
+ return EINVAL;
} /* int rc_config_get_xff */
static int rc_config_add_timespan(int timespan) {
int *tmp;
if (timespan <= 0)
- return (EINVAL);
+ return EINVAL;
tmp = realloc(rrdcreate_config.timespans,
sizeof(*rrdcreate_config.timespans) *
(rrdcreate_config.timespans_num + 1));
if (tmp == NULL)
- return (ENOMEM);
+ return ENOMEM;
rrdcreate_config.timespans = tmp;
rrdcreate_config.timespans[rrdcreate_config.timespans_num] = timespan;
rrdcreate_config.timespans_num++;
- return (0);
+ return 0;
} /* int rc_config_add_timespan */
static int rc_config(oconfig_item_t *ci) {
plugin_register_write("rrdcached", rc_write, /* user_data = */ NULL);
plugin_register_flush("rrdcached", rc_flush, /* user_data = */ NULL);
}
- return (0);
+ return 0;
} /* int rc_config */
static int try_reconnect(void) {
ERROR("rrdcached plugin: Failed to reconnect to RRDCacheD "
"at %s: %s (status=%d)",
daemon_address, rrd_get_error(), status);
- return (-1);
+ return -1;
}
INFO("rrdcached plugin: Successfully reconnected to RRDCacheD "
"at %s",
daemon_address);
- return (0);
+ return 0;
} /* int try_reconnect */
static int rc_read(void) {
vl.values_len = 1;
if (daemon_address == NULL)
- return (-1);
+ return -1;
if (!config_collect_stats)
- return (-1);
+ return -1;
if ((strncmp("unix:", daemon_address, strlen("unix:")) != 0) &&
(daemon_address[0] != '/'))
ERROR("rrdcached plugin: Failed to connect to RRDCacheD "
"at %s: %s (status=%d)",
daemon_address, rrd_get_error(), status);
- return (-1);
+ return -1;
}
while (42) {
ERROR("rrdcached plugin: rrdc_stats_get failed: %s (status=%i).",
rrd_get_error(), status);
- return (-1);
+ return -1;
}
for (rrdc_stats_t *ptr = head; ptr != NULL; ptr = ptr->next) {
rrdc_stats_free(head);
- return (0);
+ return 0;
} /* int rc_read */
static int rc_init(void) {
if (config_collect_stats)
plugin_register_read("rrdcached", rc_read);
- return (0);
+ return 0;
} /* int rc_init */
static int rc_write(const data_set_t *ds, const value_list_t *vl,
if (daemon_address == NULL) {
ERROR("rrdcached plugin: daemon_address == NULL.");
plugin_unregister_write("rrdcached");
- return (-1);
+ return -1;
}
if (strcmp(ds->type, vl->type) != 0) {
ERROR("rrdcached plugin: DS type does not match value list type");
- return (-1);
+ return -1;
}
if (value_list_to_filename(filename, sizeof(filename), vl) != 0) {
ERROR("rrdcached plugin: value_list_to_filename failed.");
- return (-1);
+ return -1;
}
if (value_list_to_string(values, sizeof(values), ds, vl) != 0) {
ERROR("rrdcached plugin: value_list_to_string failed.");
- return (-1);
+ return -1;
}
values_array[0] = values;
char errbuf[1024];
ERROR("rrdcached plugin: stat (%s) failed: %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
status = cu_rrd_create_file(filename, ds, vl, &rrdcreate_config);
if (status != 0) {
ERROR("rrdcached plugin: cu_rrd_create_file (%s) failed.", filename);
- return (-1);
+ return -1;
} else if (rrdcreate_config.async)
- return (0);
+ return 0;
}
}
ERROR("rrdcached plugin: Failed to connect to RRDCacheD "
"at %s: %s (status=%d)",
daemon_address, rrd_get_error(), status);
- return (-1);
+ return -1;
}
while (42) {
ERROR("rrdcached plugin: rrdc_update (%s, [%s], 1) failed: %s (status=%i)",
filename, values_array[0], rrd_get_error(), status);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int rc_write */
static int rc_flush(__attribute__((unused)) cdtime_t timeout, /* {{{ */
_Bool retried = 0;
if (identifier == NULL)
- return (EINVAL);
+ return EINVAL;
if (datadir != NULL)
ssnprintf(filename, sizeof(filename), "%s/%s.rrd", datadir, identifier);
ERROR("rrdcached plugin: Failed to connect to RRDCacheD "
"at %s: %s (status=%d)",
daemon_address, rrd_get_error(), status);
- return (-1);
+ return -1;
}
while (42) {
ERROR("rrdcached plugin: rrdc_flush (%s) failed: %s (status=%i).", filename,
rrd_get_error(), status);
- return (-1);
+ return -1;
}
DEBUG("rrdcached plugin: rrdc_flush (%s): Success.", filename);
- return (0);
+ return 0;
} /* }}} int rc_flush */
static int rc_shutdown(void) {
rrdc_disconnect();
- return (0);
+ return 0;
} /* int rc_shutdown */
void module_register(void) {
diff --git a/src/rrdtool.c b/src/rrdtool.c
index e29d637d9233b172808fef04938eab8cd1f845b5..5a71ebe827506cae7228cea8025cd62354f76d32 100644 (file)
--- a/src/rrdtool.c
+++ b/src/rrdtool.c
rrd_get_error());
}
- return (status);
+ return status;
} /* int srrd_update */
/* #endif HAVE_THREADSAFE_LIBRRD */
new_argv = malloc((new_argc + 1) * sizeof(*new_argv));
if (new_argv == NULL) {
ERROR("rrdtool plugin: malloc failed.");
- return (-1);
+ return -1;
}
new_argv[0] = "update";
sfree(new_argv);
- return (status);
+ return status;
} /* int srrd_update */
#endif /* !HAVE_THREADSAFE_LIBRRD */
tt = CDTIME_T_TO_TIME_T(vl->time);
status = ssnprintf(buffer, buffer_len, "%u", (unsigned int)tt);
if ((status < 1) || (status >= buffer_len))
- return (-1);
+ return -1;
offset = status;
for (size_t i = 0; i < ds->ds_num; i++) {
(ds->ds[i].type != DS_TYPE_GAUGE) &&
(ds->ds[i].type != DS_TYPE_DERIVE) &&
(ds->ds[i].type != DS_TYPE_ABSOLUTE))
- return (-1);
+ return -1;
if (ds->ds[i].type == DS_TYPE_COUNTER)
status = ssnprintf(buffer + offset, buffer_len - offset, ":%llu",
vl->values[i].absolute);
if ((status < 1) || (status >= (buffer_len - offset)))
- return (-1);
+ return -1;
offset += status;
} /* for ds->ds_num */
- return (0);
+ return 0;
} /* int value_list_to_string_multiple */
static int value_list_to_string(char *buffer, int buffer_len,
time_t tt;
if (ds->ds_num != 1)
- return (value_list_to_string_multiple(buffer, buffer_len, ds, vl));
+ return value_list_to_string_multiple(buffer, buffer_len, ds, vl);
tt = CDTIME_T_TO_TIME_T(vl->time);
switch (ds->ds[0].type) {
vl->values[0].absolute);
break;
default:
- return (EINVAL);
+ return EINVAL;
}
if ((status < 1) || (status >= buffer_len))
- return (ENOMEM);
+ return ENOMEM;
- return (0);
+ return 0;
} /* int value_list_to_string */
static int value_list_to_filename(char *buffer, size_t buffer_size,
size_t datadir_len = strlen(datadir) + 1;
if (datadir_len >= buffer_size)
- return (ENOMEM);
+ return ENOMEM;
sstrncpy(buffer, datadir, buffer_size);
buffer[datadir_len - 1] = '/';
status = FORMAT_VL(buffer, buffer_size, vl);
if (status != 0)
- return (status);
+ return status;
len = strlen(buffer);
assert(len < buffer_size);
buffer_size -= len;
if (buffer_size <= sizeof(suffix))
- return (ENOMEM);
+ return ENOMEM;
memcpy(buffer, suffix, sizeof(suffix));
- return (0);
+ return 0;
} /* int value_list_to_filename */
static void *rrd_queue_thread(void __attribute__((unused)) * data) {
} /* while (42) */
pthread_exit((void *)0);
- return ((void *)0);
+ return (void *)0;
} /* void *rrd_queue_thread */
static int rrd_queue_enqueue(const char *filename, rrd_queue_t **head,
queue_entry = malloc(sizeof(*queue_entry));
if (queue_entry == NULL)
- return (-1);
+ return -1;
queue_entry->filename = strdup(filename);
if (queue_entry->filename == NULL) {
free(queue_entry);
- return (-1);
+ return -1;
}
queue_entry->next = NULL;
pthread_cond_signal(&queue_cond);
pthread_mutex_unlock(&queue_lock);
- return (0);
+ return 0;
} /* int rrd_queue_enqueue */
static int rrd_queue_dequeue(const char *filename, rrd_queue_t **head,
if (this == NULL) {
pthread_mutex_unlock(&queue_lock);
- return (-1);
+ return -1;
}
if (prev == NULL)
sfree(this->filename);
sfree(this);
- return (0);
+ return 0;
} /* int rrd_queue_dequeue */
/* XXX: You must hold "cache_lock" when calling this function! */
if (identifier == NULL) {
rrd_cache_flush(timeout);
- return (0);
+ return 0;
}
now = cdtime();
INFO("rrdtool plugin: rrd_cache_flush_identifier: "
"c_avl_get (%s) failed. Does that file really exist?",
key);
- return (status);
+ return status;
}
if (rc->flags == FLAG_FLUSHQ) {
rc->flags = FLAG_FLUSHQ;
}
- return (status);
+ return status;
} /* int rrd_cache_flush_identifier */
static int64_t rrd_get_random_variation(void) {
long max;
if (random_timeout == 0)
- return (0);
+ return 0;
/* Assure that "cache_timeout + random_variation" is never negative. */
if (random_timeout > cache_timeout) {
max = (long)(random_timeout / 2);
min = max - ((long)random_timeout);
- return ((int64_t)cdrand_range(min, max));
+ return (int64_t)cdrand_range(min, max);
} /* int64_t rrd_get_random_variation */
static int rrd_cache_insert(const char *filename, const char *value,
if (cache == NULL) {
pthread_mutex_unlock(&cache_lock);
WARNING("rrdtool plugin: cache == NULL.");
- return (-1);
+ return -1;
}
c_avl_get(cache, filename, (void *)&rc);
rc = malloc(sizeof(*rc));
if (rc == NULL) {
pthread_mutex_unlock(&cache_lock);
- return (-1);
+ return -1;
}
rc->values_num = 0;
rc->values = NULL;
DEBUG("rrdtool plugin: (rc->last_value = %" PRIu64 ") "
">= (value_time = %" PRIu64 ")",
rc->last_value, value_time);
- return (-1);
+ return -1;
}
values_new =
sfree(cache_key);
sfree(rc->values);
sfree(rc);
- return (-1);
+ return -1;
}
rc->values = values_new;
sfree(rc->values[0]);
sfree(rc->values);
sfree(rc);
- return (-1);
+ return -1;
}
c_avl_insert(cache, cache_key, rc);
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
} /* int rrd_cache_insert */
static int rrd_cache_destroy(void) /* {{{ */
if (cache == NULL) {
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
}
while (c_avl_pick(cache, &key, &value) == 0) {
}
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
} /* }}} int rrd_cache_destroy */
static int rrd_compare_numeric(const void *a_ptr, const void *b_ptr) {
int b = *((int *)b_ptr);
if (a < b)
- return (-1);
+ return -1;
else if (a > b)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* int rrd_compare_numeric */
static int rrd_write(const data_set_t *ds, const value_list_t *vl,
int status;
if (do_shutdown)
- return (0);
+ return 0;
if (0 != strcmp(ds->type, vl->type)) {
ERROR("rrdtool plugin: DS type does not match value list type");
}
if (value_list_to_filename(filename, sizeof(filename), vl) != 0)
- return (-1);
+ return -1;
if (value_list_to_string(values, sizeof(values), ds, vl) != 0)
- return (-1);
+ return -1;
if (stat(filename, &statbuf) == -1) {
if (errno == ENOENT) {
status = cu_rrd_create_file(filename, ds, vl, &rrdcreate_config);
if (status != 0)
- return (-1);
+ return -1;
else if (rrdcreate_config.async)
- return (0);
+ return 0;
} else {
char errbuf[1024];
ERROR("stat(%s) failed: %s", filename,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
} else if (!S_ISREG(statbuf.st_mode)) {
ERROR("stat(%s): Not a regular file!", filename);
- return (-1);
+ return -1;
}
status = rrd_cache_insert(filename, values, vl->time);
- return (status);
+ return status;
} /* int rrd_write */
static int rrd_flush(cdtime_t timeout, const char *identifier,
if (cache == NULL) {
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
}
rrd_cache_flush_identifier(timeout, identifier);
pthread_mutex_unlock(&cache_lock);
- return (0);
+ return 0;
} /* int rrd_flush */
static int rrd_config(const char *key, const char *value) {
"be greater than 0.\n");
ERROR("rrdtool: `CacheTimeout' must "
"be greater than 0.\n");
- return (1);
+ return 1;
}
cache_timeout = DOUBLE_TO_CDTIME_T(tmp);
} else if (strcasecmp("CacheFlush", key) == 0) {
"be greater than 0.\n");
ERROR("rrdtool: `CacheFlush' must "
"be greater than 0.\n");
- return (1);
+ return 1;
}
cache_flush_timeout = tmp;
} else if (strcasecmp("DataDir", key) == 0) {
tmp = strdup(value);
if (tmp == NULL) {
ERROR("rrdtool plugin: strdup failed.");
- return (1);
+ return 1;
}
len = strlen(tmp);
if (len == 0) {
ERROR("rrdtool plugin: Invalid \"DataDir\" option.");
sfree(tmp);
- return (1);
+ return 1;
}
if (datadir != NULL) {
"be greater than 0.\n");
ERROR("rrdtool: `RRARows' must "
"be greater than 0.\n");
- return (1);
+ return 1;
}
rrdcreate_config.rrarows = tmp;
} else if (strcasecmp("RRATimespan", key) == 0) {
value_copy = strdup(value);
if (value_copy == NULL)
- return (1);
+ return 1;
dummy = value_copy;
while ((ptr = strtok_r(dummy, ", \t", &saveptr)) != NULL) {
fprintf(stderr, "rrdtool: realloc failed.\n");
ERROR("rrdtool: realloc failed.\n");
free(value_copy);
- return (1);
+ return 1;
}
rrdcreate_config.timespans = tmp_alloc;
rrdcreate_config.timespans[rrdcreate_config.timespans_num] = atoi(ptr);
"be in the range 0 to 1 (exclusive).");
ERROR("rrdtool: `XFF' must "
"be in the range 0 to 1 (exclusive).");
- return (1);
+ return 1;
}
rrdcreate_config.xff = tmp;
} else if (strcasecmp("WritesPerSecond", key) == 0) {
if (wps < 0.0) {
fprintf(stderr, "rrdtool: `WritesPerSecond' must be "
"greater than or equal to zero.");
- return (1);
+ return 1;
} else if (wps == 0.0) {
write_rate = 0.0;
} else {
random_timeout = DOUBLE_TO_CDTIME_T(tmp);
}
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int rrd_config */
static int rrd_shutdown(void) {
rrd_cache_destroy();
- return (0);
+ return 0;
} /* int rrd_shutdown */
static int rrd_init(void) {
int status;
if (init_once != 0)
- return (0);
+ return 0;
init_once = 1;
if (rrdcreate_config.heartbeat <= 0)
if (cache == NULL) {
pthread_mutex_unlock(&cache_lock);
ERROR("rrdtool plugin: c_avl_create failed.");
- return (-1);
+ return -1;
}
cache_flush_last = cdtime();
/* args = */ NULL, "rrdtool queue");
if (status != 0) {
ERROR("rrdtool plugin: Cannot create queue-thread.");
- return (-1);
+ return -1;
}
queue_thread_running = 1;
rrdcreate_config.heartbeat, rrdcreate_config.rrarows,
rrdcreate_config.xff);
- return (0);
+ return 0;
} /* int rrd_init */
void module_register(void) {
diff --git a/src/sensors.c b/src/sensors.c
index 2c09006b2f0a431d65a9ff1e8d57501b84019054..ed87c30c251318a543a07a229bd48a81dd62931a 100644 (file)
--- a/src/sensors.c
+++ b/src/sensors.c
chip->addr);
}
- return (status);
+ return status;
} /* int sensors_snprintf_chip_name */
static int sensors_feature_name_to_type(const char *name) {
* it's a one time cost.. */
for (int i = 0; i < known_features_num; i++)
if (strcasecmp(known_features[i].label, name) == 0)
- return (known_features[i].type);
+ return known_features[i].type;
- return (SENSOR_TYPE_UNKNOWN);
+ return SENSOR_TYPE_UNKNOWN;
} /* int sensors_feature_name_to_type */
#endif
if (ignorelist_add(sensor_list, value)) {
ERROR("sensors plugin: "
"Cannot add value to ignorelist.");
- return (1);
+ return 1;
}
} else if (strcasecmp(key, "IgnoreSelected") == 0) {
ignorelist_set_invert(sensor_list, 1);
}
#endif
else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void sensors_free_features(void) {
char errbuf[1024];
ERROR("sensors plugin: fopen(%s) failed: %s", conffile,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
}
if (status != 0) {
ERROR("sensors plugin: Cannot initialize sensors. "
"Data will not be collected.");
- return (-1);
+ return -1;
}
#if SENSORS_API_VERSION < 0x400
sensors_cleanup();
INFO("sensors plugin: lm_sensors reports no "
"features. Data will not be collected.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int sensors_load_conf */
static int sensors_shutdown(void) {
sensors_free_features();
ignorelist_free(sensor_list);
- return (0);
+ return 0;
} /* int sensors_shutdown */
static void sensors_submit(const char *plugin_instance, const char *type,
static int sensors_read(void) {
if (sensors_load_conf() != 0)
- return (-1);
+ return -1;
#if SENSORS_API_VERSION < 0x400
for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next) {
} /* for fl = first_feature .. NULL */
#endif /* (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */
- return (0);
+ return 0;
} /* int sensors_read */
void module_register(void) {
diff --git a/src/serial.c b/src/serial.c
index 5057fd3ad8342f871f3820a425294a52a93722b8..fda878706621a83ea5d7bee1cca77908a8884deb 100644 (file)
--- a/src/serial.c
+++ b/src/serial.c
(fh = fopen("/proc/tty/driver/ttyS", "r")) == NULL) {
char errbuf[1024];
WARNING("serial: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
}
fclose(fh);
- return (0);
+ return 0;
} /* int serial_read */
void module_register(void) {
diff --git a/src/smart.c b/src/smart.c
index 3188d1c85823987547413e7c5f6b4af3dbeae395..0e4e192c56579ecd7641c37eb31c8b07ad9da1a8 100644 (file)
--- a/src/smart.c
+++ b/src/smart.c
if (ignorelist == NULL)
ignorelist = ignorelist_create(/* invert = */ 1);
if (ignorelist == NULL)
- return (1);
+ return 1;
if (strcasecmp("Disk", key) == 0) {
ignorelist_add(ignorelist, value);
if (IS_TRUE(value))
use_serial = 1;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int smart_config */
static void smart_submit(const char *dev, const char *type,
handle_udev = udev_new();
if (!handle_udev) {
ERROR("smart plugin: unable to initialize udev.");
- return (-1);
+ return -1;
}
enumerate = udev_enumerate_new(handle_udev);
udev_enumerate_add_match_subsystem(enumerate, "block");
udev_enumerate_unref(enumerate);
udev_unref(handle_udev);
- return (0);
+ return 0;
} /* int smart_read */
static int smart_init(void) {
"running \"setcap cap_sys_rawio=ep\" on the collectd binary.");
}
#endif
- return (0);
+ return 0;
} /* int smart_init */
void module_register(void) {
diff --git a/src/snmp.c b/src/snmp.c
index ff75edbe882a27c504dfe349f1b4cd9db6e76f98..8f6a1460f181335995822026b430a2fd08f11787 100644 (file)
--- a/src/snmp.c
+++ b/src/snmp.c
}
static int csnmp_oid_compare(oid_t const *left, oid_t const *right) {
- return (
- snmp_oid_compare(left->oid, left->oid_len, right->oid, right->oid_len));
+ return snmp_oid_compare(left->oid, left->oid_len, right->oid,
+ right->oid_len);
}
static int csnmp_oid_suffix(oid_t *dst, oid_t const *src, oid_t const *root) {
/* Make sure "src" is in "root"s subtree. */
if (src->oid_len <= root->oid_len)
- return (EINVAL);
+ return EINVAL;
if (snmp_oid_ncompare(root->oid, root->oid_len, src->oid, src->oid_len,
/* n = */ root->oid_len) != 0)
- return (EINVAL);
+ return EINVAL;
memset(dst, 0, sizeof(*dst));
dst->oid_len = src->oid_len - root->oid_len;
memcpy(dst->oid, &src->oid[root->oid_len],
dst->oid_len * sizeof(dst->oid[0]));
- return (0);
+ return 0;
}
static int csnmp_oid_to_string(char *buffer, size_t buffer_size,
oid_str_ptr[i] = oid_str[i];
}
- return (strjoin(buffer, buffer_size, oid_str_ptr, o->oid_len,
- /* separator = */ "."));
+ return strjoin(buffer, buffer_size, oid_str_ptr, o->oid_len, ".");
}
static void csnmp_host_close_session(host_definition_t *host) /* {{{ */
if (!read_objid(buffer, dd->instance.oid.oid, &dd->instance.oid.oid_len)) {
ERROR("snmp plugin: read_objid (%s) failed.", buffer);
- return (-1);
+ return -1;
}
} else {
/* Instance is a simple string */
sstrncpy(dd->instance.string, buffer, sizeof(dd->instance.string));
}
- return (0);
+ return 0;
} /* int csnmp_config_add_data_instance */
static int csnmp_config_add_data_instance_prefix(data_definition_t *dd,
WARNING("snmp plugin: data %s: InstancePrefix is ignored when `Table' "
"is set to `false'.",
dd->name);
- return (-1);
+ return -1;
}
status = cf_util_get_string(ci, &dd->instance_prefix);
oconfig_item_t *ci) {
if (ci->values_num < 1) {
WARNING("snmp plugin: `Values' needs at least one argument.");
- return (-1);
+ return -1;
}
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);
+ return -1;
}
sfree(dd->values);
dd->values_len = 0;
dd->values = malloc(sizeof(*dd->values) * ci->values_num);
if (dd->values == NULL)
- return (-1);
+ return -1;
dd->values_len = (size_t)ci->values_num;
for (int i = 0; i < ci->values_num; i++) {
free(dd->values);
dd->values = NULL;
dd->values_len = 0;
- return (-1);
+ return -1;
}
}
- return (0);
+ return 0;
} /* int csnmp_config_add_data_instance */
static int csnmp_config_add_data_blacklist(data_definition_t *dd,
oconfig_item_t *ci) {
if (ci->values_num < 1)
- return (0);
+ return 0;
for (int i = 0; i < ci->values_num; i++) {
if (ci->values[i].type != OCONFIG_TYPE_STRING) {
WARNING("snmp plugin: `Ignore' needs only string argument.");
- return (-1);
+ return -1;
}
}
ci->values[i].value.string) != 0) {
ERROR("snmp plugin: Can't allocate memory");
strarray_free(dd->ignores, dd->ignores_len);
- return (ENOMEM);
+ return ENOMEM;
}
}
return 0;
@@ -333,12 +332,12 @@ static int csnmp_config_add_data_blacklist_match_inverted(data_definition_t *dd,
oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) {
WARNING("snmp plugin: `InvertMatch' needs exactly one boolean argument.");
- return (-1);
+ return -1;
}
dd->invert_match = ci->values[0].value.boolean ? 1 : 0;
- return (0);
+ return 0;
} /* int csnmp_config_add_data_blacklist_match_inverted */
static int csnmp_config_add_data(oconfig_item_t *ci) {
dd = calloc(1, sizeof(*dd));
if (dd == NULL)
- return (-1);
+ return -1;
status = cf_util_get_string(ci, &dd->name);
if (status != 0) {
free(dd);
- return (-1);
+ return -1;
}
dd->scale = 1.0;
sfree(dd->values);
sfree(dd->ignores);
sfree(dd);
- return (-1);
+ return -1;
}
DEBUG("snmp plugin: dd = { name = %s, type = %s, is_table = %s, values_len = "
last->next = dd;
}
- return (0);
+ return 0;
} /* int csnmp_config_add_data */
static int csnmp_config_add_host_version(host_definition_t *hd,
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) {
WARNING("snmp plugin: The `Version' config option needs exactly one number "
"argument.");
- return (-1);
+ return -1;
}
version = (int)ci->values[0].value.number;
if ((version < 1) || (version > 3)) {
WARNING("snmp plugin: `Version' must either be `1', `2', or `3'.");
- return (-1);
+ return -1;
}
hd->version = version;
- return (0);
+ return 0;
} /* int csnmp_config_add_host_address */
static int csnmp_config_add_host_collect(host_definition_t *host,
if (ci->values_num < 1) {
WARNING("snmp plugin: `Collect' needs at least one argument.");
- return (-1);
+ return -1;
}
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);
+ return -1;
}
data_list_len = host->data_list_len + ci->values_num;
data_list =
realloc(host->data_list, sizeof(data_definition_t *) * data_list_len);
if (data_list == NULL)
- return (-1);
+ return -1;
host->data_list = data_list;
for (int i = 0; i < ci->values_num; i++) {
host->data_list_len++;
} /* for (values_num) */
- return (0);
+ return 0;
} /* int csnmp_config_add_host_collect */
static int csnmp_config_add_host_auth_protocol(host_definition_t *hd,
} else {
WARNING("snmp plugin: The `AuthProtocol' config option must be `MD5' or "
"`SHA'.");
- return (-1);
+ return -1;
}
DEBUG("snmp plugin: host = %s; host->auth_protocol = %s;", hd->name,
hd->auth_protocol == usmHMACMD5AuthProtocol ? "MD5" : "SHA");
- return (0);
+ return 0;
} /* int csnmp_config_add_host_auth_protocol */
static int csnmp_config_add_host_priv_protocol(host_definition_t *hd,
} else {
WARNING("snmp plugin: The `PrivProtocol' config option must be `AES' or "
"`DES'.");
- return (-1);
+ return -1;
}
DEBUG("snmp plugin: host = %s; host->priv_protocol = %s;", hd->name,
hd->priv_protocol == usmAESPrivProtocol ? "AES" : "DES");
- return (0);
+ return 0;
} /* int csnmp_config_add_host_priv_protocol */
static int csnmp_config_add_host_security_level(host_definition_t *hd,
else {
WARNING("snmp plugin: The `SecurityLevel' config option must be "
"`noAuthNoPriv', `authNoPriv', or `authPriv'.");
- return (-1);
+ return -1;
}
DEBUG("snmp plugin: host = %s; host->security_level = %d;", hd->name,
hd->security_level);
- return (0);
+ return 0;
} /* int csnmp_config_add_host_security_level */
static int csnmp_config_add_host(oconfig_item_t *ci) {
hd = calloc(1, sizeof(*hd));
if (hd == NULL)
- return (-1);
+ return -1;
hd->version = 2;
C_COMPLAIN_INIT(&hd->complaint);
if (status != 0) {
csnmp_host_definition_destroy(hd);
- return (-1);
+ return -1;
}
DEBUG("snmp plugin: hd = { name = %s, address = %s, community = %s, version "
if (status != 0) {
ERROR("snmp plugin: Registering complex read function failed.");
csnmp_host_definition_destroy(hd);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int csnmp_config_add_host */
static int csnmp_config(oconfig_item_t *ci) {
}
} /* for (ci->children) */
- return (0);
+ return 0;
} /* int csnmp_config */
/* }}} End of the config stuff. Now the interesting part begins */
ret.gauge = NAN;
}
- return (ret);
+ return ret;
} /* value_t csnmp_value_list_to_value */
/* csnmp_strvbcopy_hexstring converts the bit string contained in "vb" to a hex
(uint8_t)vb->val.string[2], (uint8_t)vb->val.string[3]);
} else {
dst[0] = 0;
- return (EINVAL);
+ return EINVAL;
}
num_chars = dst_size - 1;
for (size_t i = 0; i < num_chars; i++) {
/* Check for control characters. */
if ((unsigned char)src[i] < 32)
- return (csnmp_strvbcopy_hexstring(dst, vb, dst_size));
+ return csnmp_strvbcopy_hexstring(dst, vb, dst_size);
dst[i] = src[i];
}
dst[num_chars] = 0;
vb = vb->next_variable)
/* do nothing */;
if (vb == NULL)
- return (-1);
+ return -1;
csnmp_oid_init(&vb_name, vb->name, vb->name_length);
il = calloc(1, sizeof(*il));
if (il == NULL) {
ERROR("snmp plugin: calloc failed.");
- return (-1);
+ return -1;
}
il->next = NULL;
status = csnmp_oid_suffix(&il->suffix, &vb_name, &dd->instance.oid);
if (status != 0) {
sfree(il);
- return (status);
+ return status;
}
/* Get instance name */
(*tail)->next = il;
*tail = il;
- return (0);
+ return 0;
} /* int csnmp_instance_list_add */
static int csnmp_dispatch_table(host_definition_t *host,
ds = plugin_get_ds(data->type);
if (!ds) {
ERROR("snmp plugin: DataSet `%s' not defined.", data->type);
- return (-1);
+ return -1;
}
assert(ds->ds_num == data->values_len);
assert(data->values_len > 0);
value_table_ptr = calloc(data->values_len, sizeof(*value_table_ptr));
if (value_table_ptr == NULL)
- return (-1);
+ return -1;
for (i = 0; i < data->values_len; i++)
value_table_ptr[i] = value_table[i];
if (vl.values == NULL) {
ERROR("snmp plugin: malloc failed.");
sfree(value_table_ptr);
- return (-1);
+ return -1;
}
sstrncpy(vl.host, host->name, sizeof(vl.host));
sfree(vl.values);
sfree(value_table_ptr);
- return (0);
+ return 0;
} /* int csnmp_dispatch_table */
static int csnmp_read_table(host_definition_t *host, data_definition_t *data) {
@@ -1292,20 +1291,20 @@ static int csnmp_read_table(host_definition_t *host, data_definition_t *data) {
if (host->sess_handle == NULL) {
DEBUG("snmp plugin: csnmp_read_table: host->sess_handle == NULL");
- return (-1);
+ return -1;
}
ds = plugin_get_ds(data->type);
if (!ds) {
ERROR("snmp plugin: DataSet `%s' not defined.", data->type);
- return (-1);
+ return -1;
}
if (ds->ds_num != data->values_len) {
ERROR("snmp plugin: DataSet `%s' requires %zu values, but config talks "
"about %zu",
data->type, ds->ds_num, data->values_len);
- return (-1);
+ return -1;
}
assert(data->values_len > 0);
@@ -1328,7 +1327,7 @@ static int csnmp_read_table(host_definition_t *host, data_definition_t *data) {
ERROR("snmp plugin: csnmp_read_table: calloc failed.");
sfree(value_list_head);
sfree(value_list_tail);
- return (-1);
+ return -1;
}
instance_list_head = NULL;
@@ -1517,7 +1516,7 @@ static int csnmp_read_table(host_definition_t *host, data_definition_t *data) {
sfree(value_list_head);
sfree(value_list_tail);
- return (0);
+ return 0;
} /* int csnmp_read_table */
static int csnmp_read_value(host_definition_t *host, data_definition_t *data) {
@@ -1536,26 +1535,26 @@ static int csnmp_read_value(host_definition_t *host, data_definition_t *data) {
if (host->sess_handle == NULL) {
DEBUG("snmp plugin: csnmp_read_value: host->sess_handle == NULL");
- return (-1);
+ return -1;
}
ds = plugin_get_ds(data->type);
if (!ds) {
ERROR("snmp plugin: DataSet `%s' not defined.", data->type);
- return (-1);
+ return -1;
}
if (ds->ds_num != data->values_len) {
ERROR("snmp plugin: DataSet `%s' requires %zu values, but config talks "
"about %zu",
data->type, ds->ds_num, data->values_len);
- return (-1);
+ return -1;
}
vl.values_len = ds->ds_num;
vl.values = malloc(sizeof(*vl.values) * vl.values_len);
if (vl.values == NULL)
- return (-1);
+ return -1;
for (i = 0; i < vl.values_len; i++) {
if (ds->ds[i].type == DS_TYPE_COUNTER)
vl.values[i].counter = 0;
@@ -1574,7 +1573,7 @@ static int csnmp_read_value(host_definition_t *host, data_definition_t *data) {
if (req == NULL) {
ERROR("snmp plugin: snmp_pdu_create failed.");
sfree(vl.values);
- return (-1);
+ return -1;
}
for (i = 0; i < data->values_len; i++)
@@ -1596,7 +1595,7 @@ static int csnmp_read_value(host_definition_t *host, data_definition_t *data) {
sfree(vl.values);
csnmp_host_close_session(host);
- return (-1);
+ return -1;
}
for (vb = res->variables; vb != NULL; vb = vb->next_variable) {
@@ -1620,7 +1619,7 @@ static int csnmp_read_value(host_definition_t *host, data_definition_t *data) {
plugin_dispatch_values(&vl);
sfree(vl.values);
- return (0);
+ return 0;
} /* int csnmp_read_value */
static int csnmp_read_host(user_data_t *ud) {
csnmp_host_open_session(host);
if (host->sess_handle == NULL)
- return (-1);
+ return -1;
success = 0;
for (i = 0; i < host->data_list_len; i++) {
}
if (success == 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
} /* int csnmp_read_host */
static int csnmp_init(void) {
call_snmp_init_once();
- return (0);
+ return 0;
} /* int csnmp_init */
static int csnmp_shutdown(void) {
data_this = data_next;
}
- return (0);
+ return 0;
} /* int csnmp_shutdown */
void module_register(void) {
diff --git a/src/statsd.c b/src/statsd.c
index aa4e35c52da887cc13754a3e9215d32482992ac7..e1b52cbc70651333eb5625b66449c2e637119b77 100644 (file)
--- a/src/statsd.c
+++ b/src/statsd.c
key[0] = 's';
break;
default:
- return (NULL);
+ return NULL;
}
key[1] = ':';
@@ -115,19 +115,19 @@ static statsd_metric_t *statsd_metric_lookup_unsafe(char const *name, /* {{{ */
status = c_avl_get(metrics_tree, key, (void *)&metric);
if (status == 0)
- return (metric);
+ return metric;
key_copy = strdup(key);
if (key_copy == NULL) {
ERROR("statsd plugin: strdup failed.");
- return (NULL);
+ return NULL;
}
metric = calloc(1, sizeof(*metric));
if (metric == NULL) {
ERROR("statsd plugin: calloc failed.");
sfree(key_copy);
- return (NULL);
+ return NULL;
}
metric->type = type;
@@ -139,10 +139,10 @@ static statsd_metric_t *statsd_metric_lookup_unsafe(char const *name, /* {{{ */
ERROR("statsd plugin: c_avl_insert failed.");
sfree(key_copy);
sfree(metric);
- return (NULL);
+ return NULL;
}
- return (metric);
+ return metric;
} /* }}} statsd_metric_lookup_unsafe */
static int statsd_metric_set(char const *name, double value, /* {{{ */
metric = statsd_metric_lookup_unsafe(name, type);
if (metric == NULL) {
pthread_mutex_unlock(&metrics_lock);
- return (-1);
+ return -1;
}
metric->value = value;
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
} /* }}} int statsd_metric_set */
static int statsd_metric_add(char const *name, double delta, /* {{{ */
metric = statsd_metric_lookup_unsafe(name, type);
if (metric == NULL) {
pthread_mutex_unlock(&metrics_lock);
- return (-1);
+ return -1;
}
metric->value += delta;
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
} /* }}} int statsd_metric_add */
static void statsd_metric_free(statsd_metric_t *metric) /* {{{ */
ret_value->gauge = (gauge_t)strtod(str, &endptr);
if ((str == endptr) || ((endptr != NULL) && (*endptr != 0)))
- return (-1);
+ return -1;
- return (0);
+ return 0;
} /* }}} int statsd_parse_value */
static int statsd_handle_counter(char const *name, /* {{{ */
int status;
if ((extra != NULL) && (extra[0] != '@'))
- return (-1);
+ return -1;
scale.gauge = 1.0;
if (extra != NULL) {
status = statsd_parse_value(extra + 1, &scale);
if (status != 0)
- return (status);
+ return status;
if (!isfinite(scale.gauge) || (scale.gauge <= 0.0) || (scale.gauge > 1.0))
- return (-1);
+ return -1;
}
value.gauge = 1.0;
status = statsd_parse_value(value_str, &value);
if (status != 0)
- return (status);
+ return status;
/* Changes to the counter are added to (statsd_metric_t*)->value. ->counter is
* only updated in statsd_metric_submit_unsafe(). */
- return (statsd_metric_add(name, (double)(value.gauge / scale.gauge),
- STATSD_COUNTER));
+ return statsd_metric_add(name, (double)(value.gauge / scale.gauge),
+ STATSD_COUNTER);
} /* }}} int statsd_handle_counter */
static int statsd_handle_gauge(char const *name, /* {{{ */
value.gauge = 0;
status = statsd_parse_value(value_str, &value);
if (status != 0)
- return (status);
+ return status;
if ((value_str[0] == '+') || (value_str[0] == '-'))
- return (statsd_metric_add(name, (double)value.gauge, STATSD_GAUGE));
+ return statsd_metric_add(name, (double)value.gauge, STATSD_GAUGE);
else
- return (statsd_metric_set(name, (double)value.gauge, STATSD_GAUGE));
+ return statsd_metric_set(name, (double)value.gauge, STATSD_GAUGE);
} /* }}} int statsd_handle_gauge */
static int statsd_handle_timer(char const *name, /* {{{ */
int status;
if ((extra != NULL) && (extra[0] != '@'))
- return (-1);
+ return -1;
scale.gauge = 1.0;
if (extra != NULL) {
status = statsd_parse_value(extra + 1, &scale);
if (status != 0)
- return (status);
+ return status;
if (!isfinite(scale.gauge) || (scale.gauge <= 0.0) || (scale.gauge > 1.0))
- return (-1);
+ return -1;
}
value_ms.derive = 0;
status = statsd_parse_value(value_str, &value_ms);
if (status != 0)
- return (status);
+ return status;
value = MS_TO_CDTIME_T(value_ms.gauge / scale.gauge);
metric = statsd_metric_lookup_unsafe(name, STATSD_TIMER);
if (metric == NULL) {
pthread_mutex_unlock(&metrics_lock);
- return (-1);
+ return -1;
}
if (metric->latency == NULL)
metric->latency = latency_counter_create();
if (metric->latency == NULL) {
pthread_mutex_unlock(&metrics_lock);
- return (-1);
+ return -1;
}
latency_counter_add(metric->latency, value);
metric->updates_num++;
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
} /* }}} int statsd_handle_timer */
static int statsd_handle_set(char const *name, /* {{{ */
metric = statsd_metric_lookup_unsafe(name, STATSD_SET);
if (metric == NULL) {
pthread_mutex_unlock(&metrics_lock);
- return (-1);
+ return -1;
}
/* Make sure metric->set exists. */
if (metric->set == NULL) {
pthread_mutex_unlock(&metrics_lock);
ERROR("statsd plugin: c_avl_create failed.");
- return (-1);
+ return -1;
}
set_key = strdup(set_key_orig);
if (set_key == NULL) {
pthread_mutex_unlock(&metrics_lock);
ERROR("statsd plugin: strdup failed.");
- return (-1);
+ return -1;
}
status = c_avl_insert(metric->set, set_key, /* value = */ NULL);
ERROR("statsd plugin: c_avl_insert (\"%s\") failed with status %i.",
set_key, status);
sfree(set_key);
- return (-1);
+ return -1;
} else if (status > 0) /* key already exists */
{
sfree(set_key);
metric->updates_num++;
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
} /* }}} int statsd_handle_set */
static int statsd_parse_line(char *buffer) /* {{{ */
type = strchr(name, '|');
if (type == NULL)
- return (-1);
+ return -1;
*type = 0;
type++;
value = strrchr(name, ':');
if (value == NULL)
- return (-1);
+ return -1;
*value = 0;
value++;
}
if (strcmp("c", type) == 0)
- return (statsd_handle_counter(name, value, extra));
+ return statsd_handle_counter(name, value, extra);
else if (strcmp("ms", type) == 0)
- return (statsd_handle_timer(name, value, extra));
+ return statsd_handle_timer(name, value, extra);
/* extra is only valid for counters and timers */
if (extra != NULL)
- return (-1);
+ return -1;
if (strcmp("g", type) == 0)
- return (statsd_handle_gauge(name, value));
+ return statsd_handle_gauge(name, value);
else if (strcmp("s", type) == 0)
- return (statsd_handle_set(name, value));
+ return statsd_handle_set(name, value);
else
- return (-1);
+ return -1;
} /* }}} void statsd_parse_line */
static void statsd_parse_buffer(char *buffer) /* {{{ */
if (status != 0) {
ERROR("statsd plugin: getaddrinfo (\"%s\", \"%s\") failed: %s", node,
service, gai_strerror(status));
- return (status);
+ return status;
}
for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
if (fds_num == 0) {
ERROR("statsd plugin: Unable to create listening socket for [%s]:%s.",
(node != NULL) ? node : "::", service);
- return (ENOENT);
+ return ENOENT;
}
*ret_fds = fds;
*ret_fds_num = fds_num;
- return (0);
+ return 0;
} /* }}} int statsd_network_init */
static void *statsd_network_thread(void *args) /* {{{ */
close(fds[i].fd);
sfree(fds);
- return ((void *)0);
+ return (void *)0;
} /* }}} void *statsd_network_thread */
static int statsd_config_timer_percentile(oconfig_item_t *ci) /* {{{ */
status = cf_util_get_double(ci, &percent);
if (status != 0)
- return (status);
+ return status;
if ((percent <= 0.0) || (percent >= 100)) {
ERROR("statsd plugin: The value for \"%s\" must be between 0 and 100, "
"exclusively.",
ci->key);
- return (ERANGE);
+ return ERANGE;
}
tmp = realloc(conf_timer_percentile, sizeof(*conf_timer_percentile) *
(conf_timer_percentile_num + 1));
if (tmp == NULL) {
ERROR("statsd plugin: realloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
conf_timer_percentile = tmp;
conf_timer_percentile[conf_timer_percentile_num] = percent;
conf_timer_percentile_num++;
- return (0);
+ return 0;
} /* }}} int statsd_config_timer_percentile */
static int statsd_config(oconfig_item_t *ci) /* {{{ */
child->key);
}
- return (0);
+ return 0;
} /* }}} int statsd_config */
static int statsd_init(void) /* {{{ */
pthread_mutex_unlock(&metrics_lock);
ERROR("statsd plugin: pthread_create failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (status);
+ return status;
}
}
network_thread_running = 1;
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
} /* }}} int statsd_init */
/* Must hold metrics_lock when calling this function. */
void *value;
if ((metric == NULL) || (metric->type != STATSD_SET))
- return (EINVAL);
+ return EINVAL;
if (metric->set == NULL)
- return (0);
+ return 0;
while (c_avl_pick(metric->set, &key, &value) == 0) {
sfree(key);
sfree(value);
}
- return (0);
+ return 0;
} /* }}} int statsd_metric_clear_set_unsafe */
/* Must hold metrics_lock when calling this function. */
}
latency_counter_reset(metric->latency);
- return (0);
+ return 0;
} else if (metric->type == STATSD_SET) {
if (metric->set == NULL)
vl.values[0].gauge = 0.0;
vl.values[0].derive = metric->counter;
}
- return (plugin_dispatch_values(&vl));
+ return plugin_dispatch_values(&vl);
} /* }}} int statsd_metric_submit_unsafe */
static int statsd_read(void) /* {{{ */
if (metrics_tree == NULL) {
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
}
iter = c_avl_get_iterator(metrics_tree);
strarray_free(to_be_deleted, to_be_deleted_num);
- return (0);
+ return 0;
} /* }}} int statsd_read */
static int statsd_shutdown(void) /* {{{ */
pthread_mutex_unlock(&metrics_lock);
- return (0);
+ return 0;
} /* }}} int statsd_shutdown */
void module_register(void) {
diff --git a/src/swap.c b/src/swap.c
index 19eed46ab0529fe4efc4f10e218826b54c36f3fd..746ba51a110c594275393f04e72d6f7198673c80 100644 (file)
--- a/src/swap.c
+++ b/src/swap.c
WARNING("swap plugin: Unknown config option: \"%s\"", child->key);
}
- return (0);
+ return 0;
} /* }}} int swap_config */
static int swap_init(void) /* {{{ */
if (kvm_obj == NULL) {
ERROR("swap plugin: kvm_openfiles failed, %s", errbuf);
- return (-1);
+ return -1;
}
/* #endif HAVE_LIBKVM_GETSWAPINFO */
pagesize = getpagesize();
#endif /* HAVE_PERFSTAT */
- return (0);
+ return 0;
} /* }}} int swap_init */
static void swap_submit_usage(char const *plugin_instance, /* {{{ */
char errbuf[1024];
WARNING("swap plugin: fopen (/proc/swaps) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
fclose(fh);
- return (0);
+ return 0;
} /* }}} int swap_read_separate */
static int swap_read_combined(void) /* {{{ */
char errbuf[1024];
WARNING("swap plugin: fopen (/proc/meminfo) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
fclose(fh);
if (isnan(swap_total) || isnan(swap_free))
- return (ENOENT);
+ return ENOENT;
/* Some systems, OpenVZ for example, don't provide SwapCached. */
if (isnan(swap_cached))
assert(!isnan(swap_used));
if (swap_used < 0.0)
- return (EINVAL);
+ return EINVAL;
swap_submit_usage(NULL, swap_used * 1024.0, swap_free * 1024.0,
isnan(swap_cached) ? NULL : "cached",
isnan(swap_cached) ? NAN : swap_cached * 1024.0);
- return (0);
+ return 0;
} /* }}} int swap_read_combined */
static int swap_read_io(void) /* {{{ */
if (fh == NULL) {
char errbuf[1024];
WARNING("swap: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
} else
old_kernel = 1;
}
fclose(fh);
if (have_data != 0x03)
- return (ENOENT);
+ return ENOENT;
if (report_bytes) {
swap_in = swap_in * pagesize;
swap_submit_derive("in", swap_in);
swap_submit_derive("out", swap_out);
- return (0);
+ return 0;
} /* }}} int swap_read_io */
static int swap_read(void) /* {{{ */
swap_read_io();
- return (0);
+ return 0;
} /* }}} int swap_read */
/* #endif KERNEL_LINUX */
char errbuf[1024];
ERROR("swap plugin: swapctl failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/*
swap_avail = (gauge_t)((ai.ani_max - ai.ani_resv) * pagesize);
swap_submit_usage(NULL, swap_alloc, swap_avail, "reserved", swap_resv);
- return (0);
+ return 0;
} /* }}} int swap_read_kstat */
/* #endif 0 && HAVE_LIBKSTAT */
swap_num = swapctl(SC_GETNSWP, NULL);
if (swap_num < 0) {
ERROR("swap plugin: swapctl (SC_GETNSWP) failed with status %i.", swap_num);
- return (-1);
+ return -1;
} else if (swap_num == 0)
- return (0);
+ return 0;
/* Allocate and initialize the swaptbl_t structure */
s = malloc(swap_num * sizeof(swapent_t) + sizeof(struct swaptable));
if (s == NULL) {
ERROR("swap plugin: malloc failed.");
- return (-1);
+ return -1;
}
/* Memory to store the path names. We only use these paths when the
if (s_paths == NULL) {
ERROR("swap plugin: calloc failed.");
sfree(s);
- return (-1);
+ return -1;
}
for (int i = 0; i < swap_num; i++)
s->swt_ent[i].ste_path = s_paths + (i * PATH_MAX);
sstrerror(errno, errbuf, sizeof(errbuf)));
sfree(s_paths);
sfree(s);
- return (-1);
+ return -1;
} else if (swap_num < status) {
/* more elements returned than requested */
ERROR("swap plugin: I allocated memory for %i structure%s, "
swap_num, (swap_num == 1) ? "" : "s", status);
sfree(s_paths);
sfree(s);
- return (-1);
+ return -1;
} else if (swap_num > status)
/* less elements returned than requested */
swap_num = status;
total, avail);
sfree(s_paths);
sfree(s);
- return (-1);
+ return -1;
}
/* If the "separate" option was specified (report_by_device == 1), all
sfree(s_paths);
sfree(s);
- return (0);
+ return 0;
} /* }}} int swap_read */
/* #endif HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS */
swap_num = swapctl(SWAP_NSWAP, NULL, 0);
if (swap_num < 0) {
ERROR("swap plugin: swapctl (SWAP_NSWAP) failed with status %i.", swap_num);
- return (-1);
+ return -1;
} else if (swap_num == 0)
- return (0);
+ return 0;
swap_entries = calloc(swap_num, sizeof(*swap_entries));
if (swap_entries == NULL) {
ERROR("swap plugin: calloc failed.");
- return (-1);
+ return -1;
}
status = swapctl(SWAP_STATS, swap_entries, swap_num);
if (status != swap_num) {
ERROR("swap plugin: swapctl (SWAP_STATS) failed with status %i.", status);
sfree(swap_entries);
- return (-1);
+ return -1;
}
#if defined(DEV_BSIZE) && (DEV_BSIZE > 0)
"swap plugin: Total swap space (%g) is less than used swap space (%g).",
total, used);
sfree(swap_entries);
- return (-1);
+ return -1;
}
swap_submit_usage(NULL, used, total - used, NULL, NAN);
sfree(swap_entries);
- return (0);
+ return 0;
} /* }}} int swap_read */
/* #endif HAVE_SWAPCTL && HAVE_SWAPCTL_THREE_ARGS */
sw_usage_len = sizeof(struct xsw_usage);
if (sysctl(mib, mib_len, &sw_usage, &sw_usage_len, NULL, 0) != 0)
- return (-1);
+ return -1;
/* The returned values are bytes. */
swap_submit_usage(NULL, (gauge_t)sw_usage.xsu_used,
(gauge_t)sw_usage.xsu_avail, NULL, NAN);
- return (0);
+ return 0;
} /* }}} int swap_read */
/* #endif VM_SWAPUSAGE */
gauge_t total;
if (kvm_obj == NULL)
- return (-1);
+ return -1;
/* only one structure => only get the grand total, no details */
status = kvm_getswapinfo(kvm_obj, &data_s, 1, 0);
if (status == -1)
- return (-1);
+ return -1;
total = (gauge_t)data_s.ksw_total;
used = (gauge_t)data_s.ksw_used;
swap_submit_usage(NULL, used, total - used, NULL, NAN);
- return (0);
+ return 0;
} /* }}} int swap_read */
/* #endif HAVE_LIBKVM_GETSWAPINFO */
swap = sg_get_swap_stats();
if (swap == NULL)
- return (-1);
+ return -1;
swap_submit_usage(NULL, (gauge_t)swap->used, (gauge_t)swap->free, NULL, NAN);
- return (0);
+ return 0;
} /* }}} int swap_read */
/* #endif HAVE_LIBSTATGRAB */
char errbuf[1024];
WARNING("swap plugin: perfstat_memory_total failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
total = (gauge_t)(pmemory.pgsp_total * pagesize);
swap_submit_derive("in", (derive_t)pmemory.pgspins * pagesize);
swap_submit_derive("out", (derive_t)pmemory.pgspouts * pagesize);
- return (0);
+ return 0;
} /* }}} int swap_read */
#endif /* HAVE_PERFSTAT */
diff --git a/src/syslog.c b/src/syslog.c
index 6d326ff1b19bd4699c85073bfc557c0e8efbae04..8192d6a151897bdaa0466946ba18abdc27e62a3a 100644 (file)
--- a/src/syslog.c
+++ b/src/syslog.c
if (log_level < 0) {
log_level = LOG_INFO;
ERROR("syslog: invalid loglevel [%s] defaulting to 'info'", value);
- return (1);
+ return 1;
}
} else if (strcasecmp(key, "NotifyLevel") == 0) {
notif_severity = parse_notif_severity(value);
if (notif_severity < 0)
- return (1);
+ return 1;
}
- return (0);
+ return 0;
} /* int sl_config */
static void sl_log(int severity, const char *msg,
static int sl_shutdown(void) {
closelog();
- return (0);
+ return 0;
}
static int sl_notification(const notification_t *n,
int status;
if (n->severity > notif_severity)
- return (0);
+ return 0;
switch (n->severity) {
case NOTIF_FAILURE:
do { \
status = ssnprintf(&buf[offset], sizeof(buf) - offset, __VA_ARGS__); \
if (status < 1) \
- return (-1); \
+ return -1; \
else if (((size_t)status) >= (sizeof(buf) - offset)) \
- return (-ENOMEM); \
+ return -ENOMEM; \
else \
offset += ((size_t)status); \
} while (0)
sl_log(log_severity, buf, NULL);
- return (0);
+ return 0;
} /* int sl_notification */
void module_register(void) {
diff --git a/src/tail.c b/src/tail.c
index 466dbffe62b676972a3fca45088f816cb47b064b..1b720b83af2fe8e52b1a58010ac29ebb9c2e6fdd 100644 (file)
--- a/src/tail.c
+++ b/src/tail.c
oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("tail plugin: `DSType' needs exactly one string argument.");
- return (-1);
+ return -1;
}
char const *ds_type = ci->values[0].value.string;
int status = latency_config(&cm->latency, ci, "tail");
if (status != 0)
- return (status);
+ return status;
} else if (strncasecmp("Counter", ds_type, strlen("Counter")) == 0) {
cm->flags = UTILS_MATCH_DS_TYPE_COUNTER;
if (strcasecmp("CounterSet", ds_type) == 0)
if (cm->flags == 0) {
WARNING("tail plugin: `%s' is not a valid argument to `DSType'.",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int ctail_config_add_match_dstype */
static int ctail_config_add_match(cu_tail_match_t *tm,
sfree(cm.type_instance);
latency_config_free(cm.latency);
- return (status);
+ return status;
} /* int ctail_config_add_match */
static int ctail_config_add_file(oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("tail plugin: `File' needs exactly one string argument.");
- return (-1);
+ return -1;
}
tm = tail_match_create(ci->values[0].value.string);
if (tm == NULL) {
ERROR("tail plugin: tail_match_create (%s) failed.",
ci->values[0].value.string);
- return (-1);
+ return -1;
}
for (int i = 0; i < ci->children_num; i++) {
ERROR("tail plugin: No (valid) matches found for file `%s'.",
ci->values[0].value.string);
tail_match_destroy(tm);
- return (-1);
+ return -1;
} else {
cu_tail_match_t **temp;
if (temp == NULL) {
ERROR("tail plugin: realloc failed.");
tail_match_destroy(tm);
- return (-1);
+ return -1;
}
tail_match_list = temp;
tail_match_list_num++;
}
- return (0);
+ return 0;
} /* int ctail_config_add_file */
static int ctail_config(oconfig_item_t *ci) {
}
} /* for (i = 0; i < ci->children_num; i++) */
- return (0);
+ return 0;
} /* int ctail_config */
static int ctail_read(user_data_t *ud) {
status = tail_match_read((cu_tail_match_t *)ud->data);
if (status != 0) {
ERROR("tail plugin: tail_match_read failed.");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int ctail_read */
static int ctail_init(void) {
if (tail_match_list_num == 0) {
WARNING("tail plugin: File list is empty. Returning an error.");
- return (-1);
+ return -1;
}
for (size_t i = 0; i < tail_match_list_num; i++) {
});
}
- return (0);
+ return 0;
} /* int ctail_init */
static int ctail_shutdown(void) {
sfree(tail_match_list);
tail_match_list_num = 0;
- return (0);
+ return 0;
} /* int ctail_shutdown */
void module_register(void) {
diff --git a/src/tail_csv.c b/src/tail_csv.c
index 425c101e1880e393f32546f89f3ec7ed236ab556..d512a52ee8188aef675dc1e6378cd09147e508d3 100644 (file)
--- a/src/tail_csv.c
+++ b/src/tail_csv.c
vl.time = t;
vl.interval = id->interval;
- return (plugin_dispatch_values(&vl));
+ return plugin_dispatch_values(&vl);
}
static cdtime_t parse_time(char const *tbuf) {
errno = 0;
t = strtod(tbuf, &endptr);
if ((errno != 0) || (endptr == NULL) || (endptr[0] != 0))
- return (cdtime());
+ return cdtime();
- return (DOUBLE_TO_CDTIME_T(t));
+ return DOUBLE_TO_CDTIME_T(t);
}
static int tcsv_read_metric(instance_definition_t *id, metric_definition_t *md,
int status;
if (md->data_source_type == -1)
- return (EINVAL);
+ return EINVAL;
assert(md->value_from >= 0);
if (((size_t)md->value_from) >= fields_num)
- return (EINVAL);
+ return EINVAL;
status = parse_value(fields[md->value_from], &v, md->data_source_type);
if (status != 0)
- return (status);
+ return status;
if (id->time_from >= 0) {
if (((size_t)id->time_from) >= fields_num)
- return (EINVAL);
+ return EINVAL;
t = parse_time(fields[id->time_from]);
}
- return (tcsv_submit(id, md, v, t));
+ return tcsv_submit(id, md, v, t);
}
static _Bool tcsv_check_index(ssize_t index, size_t fields_num,
ERROR("tail_csv plugin: Metric \"%s\": Request for index %zd when "
"only %zu fields are available.",
name, index, fields_num);
- return (0);
+ return 0;
}
static int tcsv_read_buffer(instance_definition_t *id, char *buffer,
/* Ignore empty lines. */
if ((buffer_size == 0) || (buffer[0] == '#'))
- return (0);
+ return 0;
/* Count the number of fields. */
metrics_num = 1;
ERROR("tail_csv plugin: last line of `%s' does not contain "
"enough values.",
id->path);
- return (-1);
+ return -1;
}
/* Create a list of all values */
metrics = calloc(metrics_num, sizeof(*metrics));
if (metrics == NULL) {
ERROR("tail_csv plugin: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
ptr = buffer;
/* Free up resources */
sfree(metrics);
- return (0);
+ return 0;
}
static int tcsv_read(user_data_t *ud) {
id->tail = cu_tail_create(id->path);
if (id->tail == NULL) {
ERROR("tail_csv plugin: cu_tail_create (\"%s\") failed.", id->path);
- return (-1);
+ return -1;
}
}
ERROR("tail_csv plugin: File \"%s\": cu_tail_readline failed "
"with status %i.",
id->path, status);
- return (-1);
+ return -1;
}
buffer_len = strlen(buffer);
tcsv_read_buffer(id, buffer, buffer_len);
}
- return (0);
+ return 0;
}
static void tcsv_metric_definition_destroy(void *arg) {
WARNING("tail_csv plugin: The \"%s\" config option needs exactly one "
"integer argument.",
ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].value.number < 0) {
WARNING("tail_csv plugin: The \"%s\" config option must be positive "
"(or zero).",
ci->key);
- return (-1);
+ return -1;
}
*ret_index = (ssize_t)ci->values[0].value.number;
- return (0);
+ return 0;
}
/* Parse metric */
md = calloc(1, sizeof(*md));
if (md == NULL)
- return (-1);
+ return -1;
md->name = NULL;
md->type = NULL;
md->instance = NULL;
status = cf_util_get_string(ci, &md->name);
if (status != 0) {
sfree(md);
- return (-1);
+ return -1;
}
for (int i = 0; i < ci->children_num; ++i) {
if (status != 0) {
tcsv_metric_definition_destroy(md);
- return (-1);
+ return -1;
}
/* Verify all necessary options have been set. */
}
if (status != 0) {
tcsv_metric_definition_destroy(md);
- return (status);
+ return status;
}
if (metric_head == NULL)
last->next = md;
}
- return (0);
+ return 0;
}
static void tcsv_instance_definition_destroy(void *arg) {
if (ci->values_num < 1) {
WARNING("tail_csv plugin: The `Collect' config option needs at least one "
"argument.");
- return (-1);
+ return -1;
}
metric_list_size = id->metric_list_len + (size_t)ci->values_num;
metric_list =
realloc(id->metric_list, sizeof(*id->metric_list) * metric_list_size);
if (metric_list == NULL)
- return (-1);
+ return -1;
id->metric_list = metric_list;
for (int i = 0; i < ci->values_num; i++) {
id->metric_list_len++;
}
- return (0);
+ return 0;
}
/* <File /> block */
id = calloc(1, sizeof(*id));
if (id == NULL)
- return (-1);
+ return -1;
id->instance = NULL;
id->path = NULL;
id->metric_list = NULL;
status = cf_util_get_string(ci, &id->path);
if (status != 0) {
sfree(id);
- return (status);
+ return status;
}
/* Use default interval. */
if (status != 0) {
tcsv_instance_definition_destroy(id);
- return (-1);
+ return -1;
}
/* Verify all necessary options have been set. */
if (status != 0) {
tcsv_instance_definition_destroy(id);
- return (-1);
+ return -1;
}
ssnprintf(cb_name, sizeof(cb_name), "tail_csv/%s", id->path);
if (status != 0) {
ERROR("tail_csv plugin: Registering complex read function failed.");
tcsv_instance_definition_destroy(id);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* Parse blocks */
child->key);
}
- return (0);
+ return 0;
} /* int tcsv_config */
static int tcsv_init(void) { /* {{{ */
metric_definition_t *md;
if (have_init)
- return (0);
+ return 0;
for (md = metric_head; md != NULL; md = md->next) {
data_set_t const *ds;
md->data_source_type = ds->ds->type;
}
- return (0);
+ return 0;
} /* }}} int tcsv_init */
static int tcsv_shutdown(void) {
tcsv_metric_definition_destroy(metric_head);
metric_head = NULL;
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/tape.c b/src/tape.c
index 3f4bb55b5d1b3113677dcd21dbf80debc0428ab6..debb1d28a52beb12b43f1940c7a49569d9e2f7b7 100644 (file)
--- a/src/tape.c
+++ b/src/tape.c
numtape = 0;
if (kc == NULL)
- return (-1);
+ return -1;
for (numtape = 0, ksp_chain = kc->kc_chain;
(numtape < MAX_NUMTAPE) && (ksp_chain != NULL);
ksp[numtape++] = ksp_chain;
}
- return (0);
+ return 0;
} /* int tape_init */
static void tape_submit(const char *plugin_instance, const char *type,
static kstat_io_t kio;
if (kc == NULL)
- return (-1);
+ return -1;
if (numtape <= 0)
- return (-1);
+ return -1;
for (int i = 0; i < numtape; i++) {
if (kstat_read(kc, ksp[i], &kio) == -1)
}
}
- return (0);
+ return 0;
}
void module_register(void) {
index 7c82c794dfd97bed4b52e9a3263c068e24ac012e..2041510ff97934714bc0ea62b7738d02fdf8fef5 100644 (file)
ERROR("Target `notification': The `%s' option requires exactly one string "
"argument.",
ci->key);
- return (-1);
+ return -1;
}
if ((strcasecmp("FAILURE", ci->values[0].value.string) == 0) ||
data->severity = NOTIF_FAILURE;
}
- return (0);
+ return 0;
} /* }}} int tn_config_add_severity */
static int tn_config_add_string(char **dest, /* {{{ */
char *temp;
if (dest == NULL)
- return (-EINVAL);
+ return -EINVAL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
ERROR("Target `notification': The `%s' option requires exactly one string "
"argument.",
ci->key);
- return (-1);
+ return -1;
}
if (ci->values[0].value.string[0] == 0) {
ERROR(
"Target `notification': The `%s' option does not accept empty strings.",
ci->key);
- return (-1);
+ return -1;
}
temp = sstrdup(ci->values[0].value.string);
if (temp == NULL) {
ERROR("tn_config_add_string: sstrdup failed.");
- return (-1);
+ return -1;
}
free(*dest);
*dest = temp;
- return (0);
+ return 0;
} /* }}} int tn_config_add_string */
static int tn_destroy(void **user_data) /* {{{ */
tn_data_t *data;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL)
- return (0);
+ return 0;
sfree(data->message);
sfree(data);
- return (0);
+ return 0;
} /* }}} int tn_destroy */
static int tn_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
data = calloc(1, sizeof(*data));
if (data == NULL) {
ERROR("tn_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
data->message = NULL;
if (status != 0) {
tn_destroy((void *)&data);
- return (status);
+ return status;
}
*user_data = data;
- return (0);
+ return 0;
} /* }}} int tn_create */
static int tn_invoke(const data_set_t *ds, value_list_t *vl, /* {{{ */
int rates_failed;
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL) {
ERROR("Target `notification': Invoke: `data' is NULL.");
- return (-EINVAL);
+ return -EINVAL;
}
/* Initialize the structure. */
plugin_dispatch_notification(&n);
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int tn_invoke */
void module_register(void) {
diff --git a/src/target_replace.c b/src/target_replace.c
index 2bdb3b80af6dc8114c1bae2ede9e2c4753707d2a..66fc98d4c83025e9801f81c1d25189373fbdfbd2 100644 (file)
--- a/src/target_replace.c
+++ b/src/target_replace.c
char *dest;
if (orig == NULL)
- return (NULL);
+ return NULL;
sz = strlen(orig) + 1;
dest = malloc(sz);
if (dest == NULL)
- return (NULL);
+ return NULL;
memcpy(dest, orig, sz);
- return (dest);
+ return dest;
} /* }}} char *tr_strdup */
static void tr_action_destroy(tr_action_t *act) /* {{{ */
int status;
if (dest == NULL)
- return (-EINVAL);
+ return -EINVAL;
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
ERROR("Target `replace': The `%s' option requires exactly two string "
"arguments.",
ci->key);
- return (-1);
+ return -1;
}
act = calloc(1, sizeof(*act));
if (act == NULL) {
ERROR("tr_config_add_action: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
act->replacement = NULL;
"failed: %s.",
ci->values[0].value.string, errbuf);
sfree(act);
- return (-EINVAL);
+ return -EINVAL;
}
act->replacement = tr_strdup(ci->values[1].value.string);
if (act->replacement == NULL) {
ERROR("tr_config_add_action: tr_strdup failed.");
tr_action_destroy(act);
- return (-ENOMEM);
+ return -ENOMEM;
}
/* Insert action at end of list. */
prev->next = act;
}
- return (0);
+ return 0;
} /* }}} int tr_config_add_action */
static int tr_config_add_meta_action(tr_meta_data_action_t **dest, /* {{{ */
int status;
if (dest == NULL)
- return (-EINVAL);
+ return -EINVAL;
if (should_delete) {
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
ERROR("Target `replace': The `%s' option requires exactly two string "
"arguments.",
ci->key);
- return (-1);
+ return -1;
}
} else {
if ((ci->values_num != 3) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
ERROR("Target `replace': The `%s' option requires exactly three string "
"arguments.",
ci->key);
- return (-1);
+ return -1;
}
}
ERROR("Target `replace': The `%s' option does not accept empty string as "
"first argument.",
ci->key);
- return (-1);
+ return -1;
}
act = calloc(1, sizeof(*act));
if (act == NULL) {
ERROR("tr_config_add_meta_action: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
act->key = NULL;
ci->values[1].value.string, errbuf);
sfree(act->key);
sfree(act);
- return (-EINVAL);
+ return -EINVAL;
}
act->key = tr_strdup(ci->values[0].value.string);
if (act->key == NULL) {
ERROR("tr_config_add_meta_action: tr_strdup failed.");
tr_meta_data_action_destroy(act);
- return (-ENOMEM);
+ return -ENOMEM;
}
if (!should_delete) {
if (act->replacement == NULL) {
ERROR("tr_config_add_meta_action: tr_strdup failed.");
tr_meta_data_action_destroy(act);
- return (-ENOMEM);
+ return -ENOMEM;
}
}
prev->next = act;
}
- return (0);
+ return 0;
} /* }}} int tr_config_add_meta_action */
static int tr_action_invoke(tr_action_t *act_head, /* {{{ */
regmatch_t matches[8] = {[0] = {0}};
if (act_head == NULL)
- return (-EINVAL);
+ return -EINVAL;
sstrncpy(buffer, buffer_in, sizeof(buffer));
if ((may_be_empty == 0) && (buffer[0] == 0)) {
WARNING("Target `replace': Replacement resulted in an empty string, "
"which is not allowed for this buffer (`host' or `plugin').");
- return (0);
+ return 0;
}
DEBUG("target_replace plugin: tr_action_invoke: -> buffer = %s;", buffer);
sstrncpy(buffer_in, buffer, buffer_in_size);
- return (0);
+ return 0;
} /* }}} int tr_action_invoke */
static int tr_meta_data_action_invoke(/* {{{ */
regmatch_t matches[8] = {[0] = {0}};
if (act_head == NULL)
- return (-EINVAL);
+ return -EINVAL;
if ((*dest) == NULL) /* nothing to do */
- return (0);
+ return 0;
for (tr_meta_data_action_t *act = act_head; act != NULL; act = act->next) {
char temp[DATA_MAX_NAME_LEN];
if (meta_data_status != 0) {
ERROR("Target `replace': Unable to retrieve metadata value for `%s'.",
act->key);
- return (meta_data_status);
+ return meta_data_status;
}
DEBUG("target_replace plugin: tr_meta_data_action_invoke: `%s' "
if ((result = meta_data_create()) == NULL) {
ERROR("Target `replace': failed to create metadata for `%s'.", act->key);
sfree(value);
- return (-ENOMEM);
+ return -ENOMEM;
}
meta_data_status = meta_data_add_string(result, act->key, temp);
act->key);
meta_data_destroy(result);
sfree(value);
- return (meta_data_status);
+ return meta_data_status;
}
meta_data_clone_merge(dest, result);
sfree(value);
} /* for (act = act_head; act != NULL; act = act->next) */
- return (0);
+ return 0;
} /* }}} int tr_meta_data_action_invoke */
static int tr_destroy(void **user_data) /* {{{ */
tr_data_t *data;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL)
- return (0);
+ return 0;
tr_action_destroy(data->host);
tr_action_destroy(data->plugin);
tr_meta_data_action_destroy(data->meta);
sfree(data);
- return (0);
+ return 0;
} /* }}} int tr_destroy */
static int tr_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
data = calloc(1, sizeof(*data));
if (data == NULL) {
ERROR("tr_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
data->host = NULL;
if (status != 0) {
tr_destroy((void *)&data);
- return (status);
+ return status;
}
*user_data = data;
- return (0);
+ return 0;
} /* }}} int tr_create */
static int tr_invoke(const data_set_t *ds, value_list_t *vl, /* {{{ */
tr_data_t *data;
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL) {
ERROR("Target `replace': Invoke: `data' is NULL.");
- return (-EINVAL);
+ return -EINVAL;
}
if (data->meta != NULL) {
/* HANDLE_FIELD (type, 0); */
HANDLE_FIELD(type_instance, 1);
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int tr_invoke */
void module_register(void) {
diff --git a/src/target_scale.c b/src/target_scale.c
index 4cce8dd10b6c3330da6c87302048dd9e9f44f331..8ec53d48514e50b0e80dbc885d962b26215106c6 100644 (file)
--- a/src/target_scale.c
+++ b/src/target_scale.c
uc_meta_data_add_unsigned_int(vl, key_int_counter, int_counter);
uc_meta_data_add_double(vl, key_int_fraction, int_fraction);
- return (0);
+ return 0;
} /* }}} int ts_invoke_counter */
static int ts_invoke_gauge(const data_set_t *ds, value_list_t *vl, /* {{{ */
if (!isnan(data->offset))
vl->values[dsrc_index].gauge += data->offset;
- return (0);
+ return 0;
} /* }}} int ts_invoke_gauge */
static int ts_invoke_derive(const data_set_t *ds, value_list_t *vl, /* {{{ */
uc_meta_data_add_signed_int(vl, key_int_derive, int_derive);
uc_meta_data_add_double(vl, key_int_fraction, int_fraction);
- return (0);
+ return 0;
} /* }}} int ts_invoke_derive */
static int ts_invoke_absolute(const data_set_t *ds, value_list_t *vl, /* {{{ */
/* Update to the new absolute value */
uc_meta_data_add_double(vl, key_int_fraction, int_fraction);
- return (0);
+ return 0;
} /* }}} int ts_invoke_absolute */
static int ts_config_set_double(double *ret, oconfig_item_t *ci) /* {{{ */
WARNING("scale target: The `%s' config option needs "
"exactly one numeric argument.",
ci->key);
- return (-1);
+ return -1;
}
*ret = ci->values[0].value.number;
DEBUG("ts_config_set_double: *ret = %g", *ret);
- return (0);
+ return 0;
} /* }}} int ts_config_set_double */
static int ts_config_add_data_source(ts_data_t *data, /* {{{ */
/* Check number of arbuments. */
if (ci->values_num < 1) {
ERROR("`value' match: `%s' needs at least one argument.", ci->key);
- return (-1);
+ return -1;
}
/* Check type of arguments */
ci->key, i + 1,
(ci->values[i].type == OCONFIG_TYPE_BOOLEAN) ? "truth value"
: "number");
- return (-1);
+ return -1;
}
/* Allocate space for the char pointers */
temp = realloc(data->data_sources, new_data_sources_num * sizeof(char *));
if (temp == NULL) {
ERROR("`value' match: realloc failed.");
- return (-1);
+ return -1;
}
data->data_sources = temp;
data->data_sources_num++;
}
- return (0);
+ return 0;
} /* }}} int ts_config_add_data_source */
static int ts_destroy(void **user_data) /* {{{ */
ts_data_t *data;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
data = (ts_data_t *)*user_data;
sfree(data);
*user_data = NULL;
- return (0);
+ return 0;
} /* }}} int ts_destroy */
static int ts_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
data = calloc(1, sizeof(*data));
if (data == NULL) {
ERROR("ts_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
data->factor = NAN;
if (status != 0) {
ts_destroy((void *)&data);
- return (status);
+ return status;
}
*user_data = data;
- return (0);
+ return 0;
} /* }}} int ts_create */
static int ts_invoke(const data_set_t *ds, value_list_t *vl, /* {{{ */
ts_data_t *data;
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL) {
ERROR("Target `scale': Invoke: `data' is NULL.");
- return (-EINVAL);
+ return -EINVAL;
}
for (size_t i = 0; i < ds->ds_num; i++) {
ds->ds[i].type);
}
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int ts_invoke */
void module_register(void) {
diff --git a/src/target_set.c b/src/target_set.c
index e9dbc1d022d51b1cfe4f8a7202f0cf4b849b1997..e3ec26924fbcb60160890c7d63cea9a3aa5b23d0 100644 (file)
--- a/src/target_set.c
+++ b/src/target_set.c
ERROR("ts_util_get_key_and_string_wo_strdup: The %s option requires "
"exactly two string arguments.",
ci->key);
- return (-1);
+ return -1;
}
*ret_key = ci->values[0].value.string;
*ret_string = ci->values[1].value.string;
- return (0);
+ return 0;
} /* }}} int ts_util_get_key_and_string_wo_strdup */
static int ts_config_add_string(char **dest, /* {{{ */
status = cf_util_get_string(ci, &tmp);
if (status != 0)
- return (status);
+ return status;
if (!may_be_empty && (strlen(tmp) == 0)) {
ERROR("Target `set': The `%s' option does not accept empty strings.",
ci->key);
sfree(tmp);
- return (-1);
+ return -1;
}
*dest = tmp;
- return (0);
+ return 0;
} /* }}} int ts_config_add_string */
static int ts_config_add_meta(meta_data_t **dest, /* {{{ */
status = ts_util_get_key_and_string_wo_strdup(ci, &key, &string);
if (status != 0)
- return (status);
+ return status;
if (strlen(key) == 0) {
ERROR("Target `set': The `%s' option does not accept empty string as "
"first argument.",
ci->key);
- return (-1);
+ return -1;
}
if (!may_be_empty && (strlen(string) == 0)) {
ERROR("Target `set': The `%s' option does not accept empty string as "
"second argument.",
ci->key);
- return (-1);
+ return -1;
}
if ((*dest) == NULL) {
/* Create a new meta_data_t */
if ((*dest = meta_data_create()) == NULL) {
ERROR("Target `set': failed to create a meta data for `%s'.", ci->key);
- return (-ENOMEM);
+ return -ENOMEM;
}
}
- return (meta_data_add_string(*dest, key, string));
+ return meta_data_add_string(*dest, key, string);
} /* }}} int ts_config_add_meta */
static int ts_config_add_meta_delete(ts_key_list_t **dest, /* {{{ */
entry = calloc(1, sizeof(*entry));
if (entry == NULL) {
ERROR("ts_config_add_meta_delete: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
if (cf_util_get_string(ci, &entry->key) != 0) {
ts_key_list_free(entry);
- return (-1); /* An error has already been reported. */
+ return -1; /* An error has already been reported. */
}
if (strlen(entry->key) == 0) {
"first argument.",
ci->key);
ts_key_list_free(entry);
- return (-1);
+ return -1;
}
entry->next = *dest;
*dest = entry;
- return (0);
+ return 0;
} /* }}} int ts_config_add_meta_delete */
static void ts_subst(char *dest, size_t size, const char *string, /* {{{ */
ts_data_t *data;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL)
- return (0);
+ return 0;
free(data->host);
free(data->plugin);
ts_key_list_free(data->meta_delete);
free(data);
- return (0);
+ return 0;
} /* }}} int ts_destroy */
static int ts_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
data = calloc(1, sizeof(*data));
if (data == NULL) {
ERROR("ts_create: calloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
data->host = NULL;
if (status != 0) {
ts_destroy((void *)&data);
- return (status);
+ return status;
}
*user_data = data;
- return (0);
+ return 0;
} /* }}} int ts_create */
static int ts_invoke(const data_set_t *ds, value_list_t *vl, /* {{{ */
meta_data_t *new_meta = NULL;
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
- return (-EINVAL);
+ return -EINVAL;
data = *user_data;
if (data == NULL) {
ERROR("Target `set': Invoke: `data' is NULL.");
- return (-EINVAL);
+ return -EINVAL;
}
orig = *vl;
if ((new_meta = meta_data_create()) == NULL) {
ERROR("Target `set': failed to create replacement metadata.");
- return (-ENOMEM);
+ return -ENOMEM;
}
meta_entries = meta_data_toc(data->meta, &meta_toc);
key);
strarray_free(meta_toc, (size_t)meta_entries);
meta_data_destroy(new_meta);
- return (status);
+ return status;
}
ts_subst(temp, sizeof(temp), string, &orig);
ERROR("Target `set': Unable to set metadata value `%s'.", key);
strarray_free(meta_toc, (size_t)meta_entries);
meta_data_destroy(new_meta);
- return (status);
+ return status;
}
}
meta_data_delete(vl->meta, l->key);
}
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int ts_invoke */
void module_register(void) {
diff --git a/src/target_v5upgrade.c b/src/target_v5upgrade.c
index 27bca39909f6068f26a0d0ab84093c73cbc81622..90f8e005883cf42d467e1326545116a23ed8962b 100644 (file)
--- a/src/target_v5upgrade.c
+++ b/src/target_v5upgrade.c
/* Can't upgrade if both instances have been set. */
if ((vl->plugin_instance[0] != 0) && (vl->type_instance[0] != 0))
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_df */
/*
static int v5_interface(const data_set_t *ds, value_list_t *vl) /* {{{ */
{
if ((vl->plugin_instance[0] != 0) || (vl->type_instance[0] == 0))
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
v5_swap_instances(vl);
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int v5_interface */
/*
value_list_t new_vl;
if (vl->values_len != 5)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_mysql_qcache */
/*
value_list_t new_vl;
if (vl->values_len != 4)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_mysql_threads */
/*
@@ -216,14 +216,14 @@ static int v5_zfs_arc_counts(const data_set_t *ds, value_list_t *vl) /* {{{ */
_Bool is_hits;
if (vl->values_len != 4)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
if (strcmp("hits", vl->type_instance) == 0)
is_hits = 1;
else if (strcmp("misses", vl->type_instance) == 0)
is_hits = 0;
else
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_zfs_arc_counts */
/*
@@ -271,7 +271,7 @@ static int v5_zfs_arc_l2_bytes(const data_set_t *ds, value_list_t *vl) /* {{{ */
value_list_t new_vl;
if (vl->values_len != 2)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
@@ -295,7 +295,7 @@ static int v5_zfs_arc_l2_bytes(const data_set_t *ds, value_list_t *vl) /* {{{ */
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_zfs_arc_l2_bytes */
/*
value_list_t new_vl;
if (vl->values_len != 1)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_zfs_arc_l2_size */
/*
value_list_t new_vl;
if (vl->values_len != 1)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_zfs_arc_ratio */
/*
value_list_t new_vl;
if (vl->values_len != 4)
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
/* Copy everything: Time, interval, host, ... */
memcpy(&new_vl, vl, sizeof(new_vl));
plugin_dispatch_values(&new_vl);
/* Abort processing */
- return (FC_TARGET_STOP);
+ return FC_TARGET_STOP;
} /* }}} int v5_zfs_arc_size */
static int v5_destroy(void **user_data) /* {{{ */
{
- return (0);
+ return 0;
} /* }}} int v5_destroy */
static int v5_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
{
*user_data = NULL;
- return (0);
+ return 0;
} /* }}} int v5_create */
static int v5_invoke(const data_set_t *ds, value_list_t *vl, /* {{{ */
notification_meta_t __attribute__((unused)) * *meta,
void __attribute__((unused)) * *user_data) {
if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (strcmp("df", vl->type) == 0)
- return (v5_df(ds, vl));
+ return v5_df(ds, vl);
else if (strcmp("interface", vl->plugin) == 0)
- return (v5_interface(ds, vl));
+ return v5_interface(ds, vl);
else if (strcmp("mysql_qcache", vl->type) == 0)
- return (v5_mysql_qcache(ds, vl));
+ return v5_mysql_qcache(ds, vl);
else if (strcmp("mysql_threads", vl->type) == 0)
- return (v5_mysql_threads(ds, vl));
+ return v5_mysql_threads(ds, vl);
else if (strcmp("arc_counts", vl->type) == 0)
- return (v5_zfs_arc_counts(ds, vl));
+ return v5_zfs_arc_counts(ds, vl);
else if (strcmp("arc_l2_bytes", vl->type) == 0)
- return (v5_zfs_arc_l2_bytes(ds, vl));
+ return v5_zfs_arc_l2_bytes(ds, vl);
else if (strcmp("arc_l2_size", vl->type) == 0)
- return (v5_zfs_arc_l2_size(ds, vl));
+ return v5_zfs_arc_l2_size(ds, vl);
else if (strcmp("arc_ratio", vl->type) == 0)
- return (v5_zfs_arc_ratio(ds, vl));
+ return v5_zfs_arc_ratio(ds, vl);
else if (strcmp("arc_size", vl->type) == 0)
- return (v5_zfs_arc_size(ds, vl));
+ return v5_zfs_arc_size(ds, vl);
- return (FC_TARGET_CONTINUE);
+ return FC_TARGET_CONTINUE;
} /* }}} int v5_invoke */
void module_register(void) {
diff --git a/src/tcpconns.c b/src/tcpconns.c
index 08838fbe672a3dda69aa62a08400cb60e9bbb2e3..419d8c19e8aa69242495fddabb371d06831a4586 100644 (file)
--- a/src/tcpconns.c
+++ b/src/tcpconns.c
if ((ret == NULL) && (create != 0)) {
ret = calloc(1, sizeof(*ret));
if (ret == NULL)
- return (NULL);
+ return NULL;
ret->port = port;
ret->next = port_list_head;
port_list_head = ret;
}
- return (ret);
+ return ret;
} /* port_entry_t *conn_get_port_entry */
/* Removes ports that were added automatically due to the `ListeningPorts'
NOTICE("tcpconns plugin: Ignoring connection with "
"unknown state 0x%02" PRIx8 ".",
state);
- return (-1);
+ return -1;
}
count_total[state]++;
if (pe != NULL)
pe->count_remote[state]++;
- return (0);
+ return 0;
} /* int conn_handle_ports */
#if KERNEL_LINUX
ERROR("tcpconns plugin: conn_read_netlink: socket(AF_NETLINK, SOCK_RAW, "
"NETLINK_INET_DIAG) failed: %s",
sstrerror(errno, buf, sizeof(buf)));
- return (-1);
+ return -1;
}
struct sockaddr_nl nladdr = {.nl_family = AF_NETLINK};
ERROR("tcpconns plugin: conn_read_netlink: sendmsg(2) failed: %s",
sstrerror(errno, buf, sizeof(buf)));
close(fd);
- return (-1);
+ return -1;
}
iov.iov_base = buf;
ERROR("tcpconns plugin: conn_read_netlink: recvmsg(2) failed: %s",
sstrerror(errno, buf, sizeof(buf)));
close(fd);
- return (-1);
+ return -1;
} else if (status == 0) {
close(fd);
DEBUG("tcpconns plugin: conn_read_netlink: Unexpected zero-sized "
"reply from netlink socket.");
- return (0);
+ return 0;
}
h = (struct nlmsghdr *)buf;
if (h->nlmsg_type == NLMSG_DONE) {
close(fd);
- return (0);
+ return 0;
} else if (h->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *msg_error;
msg_error->error);
close(fd);
- return (1);
+ return 1;
}
r = NLMSG_DATA(h);
} /* while (1) */
/* Not reached because the while() loop above handles the exit condition. */
- return (0);
+ return 0;
#else
- return (1);
+ return 1;
#endif /* HAVE_STRUCT_LINUX_INET_DIAG_REQ */
} /* int conn_read_netlink */
while ((buffer_len > 0) && (buffer[buffer_len - 1] < 32))
buffer[--buffer_len] = '\0';
if (buffer_len <= 0)
- return (-1);
+ return -1;
fields_len = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
if (fields_len < 12) {
DEBUG("tcpconns plugin: Got %i fields, expected at least 12.", fields_len);
- return (-1);
+ return -1;
}
port_local_str = strchr(fields[1], ':');
port_remote_str = strchr(fields[2], ':');
if ((port_local_str == NULL) || (port_remote_str == NULL))
- return (-1);
+ return -1;
port_local_str++;
port_remote_str++;
if ((*port_local_str == '\0') || (*port_remote_str == '\0'))
- return (-1);
+ return -1;
endptr = NULL;
port_local = (uint16_t)strtol(port_local_str, &endptr, 16);
if ((endptr == NULL) || (*endptr != '\0'))
- return (-1);
+ return -1;
endptr = NULL;
port_remote = (uint16_t)strtol(port_remote_str, &endptr, 16);
if ((endptr == NULL) || (*endptr != '\0'))
- return (-1);
+ return -1;
endptr = NULL;
state = (uint8_t)strtol(fields[3], &endptr, 16);
if ((endptr == NULL) || (*endptr != '\0'))
- return (-1);
+ return -1;
- return (conn_handle_ports(port_local, port_remote, state));
+ return conn_handle_ports(port_local, port_remote, state);
} /* int conn_handle_line */
static int conn_read_file(const char *file) {
fh = fopen(file, "r");
if (fh == NULL)
- return (-1);
+ return -1;
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
conn_handle_line(buffer);
fclose(fh);
- return (0);
+ return 0;
} /* int conn_read_file */
/* #endif KERNEL_LINUX */
if ((port < 1) || (port > 65535)) {
ERROR("tcpconns plugin: Invalid port: %i", port);
- return (1);
+ return 1;
}
pe = conn_get_port_entry((uint16_t)port, 1 /* create */);
if (pe == NULL) {
ERROR("tcpconns plugin: conn_get_port_entry failed.");
- return (1);
+ return 1;
}
if (strcasecmp(key, "LocalPort") == 0)
else
port_collect_total = 0;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int conn_config */
#if KERNEL_LINUX
if (port_collect_total == 0 && port_list_head == NULL)
port_collect_listening = 1;
- return (0);
+ return 0;
} /* int conn_init */
static int conn_read(void) {
linux_source = SRC_PROC;
/* return success here to avoid the "plugin failed" message. */
- return (0);
+ return 0;
}
}
if (status == 0)
conn_submit_all();
else
- return (status);
+ return status;
- return (0);
+ return 0;
} /* int conn_read */
/* #endif KERNEL_LINUX */
status = sysctlbyname("net.inet.tcp.pcblist", NULL, &buffer_len, 0, 0);
if (status < 0) {
ERROR("tcpconns plugin: sysctlbyname failed.");
- return (-1);
+ return -1;
}
buffer = malloc(buffer_len);
if (buffer == NULL) {
ERROR("tcpconns plugin: malloc failed.");
- return (-1);
+ return -1;
}
status = sysctlbyname("net.inet.tcp.pcblist", buffer, &buffer_len, 0, 0);
if (status < 0) {
ERROR("tcpconns plugin: sysctlbyname failed.");
sfree(buffer);
- return (-1);
+ return -1;
}
if (buffer_len <= sizeof(struct xinpgen)) {
ERROR("tcpconns plugin: (buffer_len <= sizeof (struct xinpgen))");
sfree(buffer);
- return (-1);
+ return -1;
}
in_orig = (struct xinpgen *)buffer;
conn_submit_all();
- return (0);
+ return 0;
} /* int conn_read */
/* #endif HAVE_SYSCTLBYNAME */
kvmd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, buf);
if (kvmd == NULL) {
ERROR("tcpconns plugin: kvm_openfiles failed: %s", buf);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int conn_init */
static int conn_read(void) {
sizeof(*kf), &fcnt);
if (kf == NULL) {
ERROR("tcpconns plugin: kvm_getfiles failed.");
- return (-1);
+ return -1;
}
for (i = 0; i < fcnt; i++) {
conn_submit_all();
- return (0);
+ return 0;
}
/* int conn_read */
/* #endif HAVE_KVM_GETFILES */
if (status != size) {
ERROR("tcpconns plugin: kvm_read failed (got %i, expected %i): %s\n",
status, size, kvm_geterr(kvmd));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int kread */
static int conn_init(void) {
kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, buf);
if (kvmd == NULL) {
ERROR("tcpconns plugin: kvm_openfiles failed: %s", buf);
- return (-1);
+ return -1;
}
status = kvm_nlist(kvmd, nl);
if (status < 0) {
ERROR("tcpconns plugin: kvm_nlist failed with status %i.", status);
- return (-1);
+ return -1;
}
if (nl[N_TCBTABLE].n_type == 0) {
ERROR("tcpconns plugin: Error looking up kernel's namelist: "
"N_TCBTABLE is invalid.");
- return (-1);
+ return -1;
}
inpcbtable_off = (u_long)nl[N_TCBTABLE].n_value;
inpcbtable_ptr = (struct inpcbtable *)nl[N_TCBTABLE].n_value;
- return (0);
+ return 0;
} /* int conn_init */
static int conn_read(void) {
/* Read the pcbtable from the kernel */
status = kread(inpcbtable_off, &table, sizeof(table));
if (status != 0)
- return (-1);
+ return -1;
#if defined(__OpenBSD__) || \
(defined(__NetBSD_Version__) && __NetBSD_Version__ > 699002700)
/* Read the pcb pointed to by `next' into `inpcb' */
status = kread((u_long)next, &inpcb, sizeof(inpcb));
if (status != 0)
- return (-1);
+ return -1;
/* Advance `next' */
#if defined(__OpenBSD__) || \
status = kread((u_long)inpcb.inp_ppcb, &tcpcb, sizeof(tcpcb));
if (status != 0)
- return (-1);
+ return -1;
conn_handle_ports(ntohs(inpcb.inp_lport), ntohs(inpcb.inp_fport),
tcpcb.t_state);
} /* while (next != head) */
conn_submit_all();
- return (0);
+ return 0;
}
/* #endif HAVE_LIBKVM_NLIST */
size = netinfo(NETINFO_TCP, 0, 0, 0);
if (size < 0) {
ERROR("tcpconns plugin: netinfo failed return: %i", size);
- return (-1);
+ return -1;
}
if (size == 0)
- return (0);
+ return 0;
if ((size - sizeof(struct netinfo_header)) % sizeof(struct netinfo_conn)) {
ERROR("tcpconns plugin: invalid buffer size");
- return (-1);
+ return -1;
}
data = malloc(size);
if (data == NULL) {
ERROR("tcpconns plugin: malloc failed");
- return (-1);
+ return -1;
}
if (netinfo(NETINFO_TCP, data, &size, 0) < 0) {
ERROR("tcpconns plugin: netinfo failed");
free(data);
- return (-1);
+ return -1;
}
header = (struct netinfo_header *)data;
conn_submit_all();
- return (0);
+ return 0;
}
#endif /* KERNEL_AIX */
diff --git a/src/teamspeak2.c b/src/teamspeak2.c
index a959cddc024ae66803000936763180cfe89c6320..a26d16e36caa90b62cf2e1cbf97e3315f9ec9f4a 100644 (file)
--- a/src/teamspeak2.c
+++ b/src/teamspeak2.c
/* Check port range */
if ((vserver_port <= 0) || (vserver_port > 65535)) {
ERROR("teamspeak2 plugin: VServer port is invalid: %i", vserver_port);
- return (-1);
+ return -1;
}
/* Allocate memory */
entry = calloc(1, sizeof(*entry));
if (entry == NULL) {
ERROR("teamspeak2 plugin: calloc failed.");
- return (-1);
+ return -1;
}
/* Save data */
INFO("teamspeak2 plugin: Registered new vserver: %i", vserver_port);
- return (0);
+ return 0;
} /* int tss2_add_vserver */
static void tss2_submit_gauge(const char *plugin_instance, const char *type,
*ret_read_fh = global_read_fh;
if (ret_write_fh != NULL)
*ret_write_fh = global_write_fh;
- return (0);
+ return 0;
}
/* Get all addrs for this hostname */
&ai_hints, &ai_head);
if (status != 0) {
ERROR("teamspeak2 plugin: getaddrinfo failed: %s", gai_strerror(status));
- return (-1);
+ return -1;
}
/* Try all given hosts until we can connect to one */
/* Check if we really got connected */
if (sd < 0)
- return (-1);
+ return -1;
/* Create file objects from sockets */
global_read_fh = fdopen(sd, "r");
ERROR("teamspeak2 plugin: fdopen failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(sd);
- return (-1);
+ return -1;
}
global_write_fh = fdopen(sd, "w");
ERROR("teamspeak2 plugin: fdopen failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
tss2_close_socket();
- return (-1);
+ return -1;
}
{ /* Check that the server correctly identifies itself. */
"to server. Expected ``[TS]'', got ``%s''.",
buffer);
tss2_close_socket();
- return (-1);
+ return -1;
}
DEBUG("teamspeak2 plugin: Server send correct banner, connected!");
}
*ret_read_fh = global_read_fh;
if (ret_write_fh != NULL)
*ret_write_fh = global_write_fh;
- return (0);
+ return 0;
} /* int tss2_get_socket */
static int tss2_send_request(FILE *fh, const char *request) {
if (status < 0) {
ERROR("teamspeak2 plugin: fputs failed.");
tss2_close_socket();
- return (-1);
+ return -1;
}
fflush(fh);
- return (0);
+ return 0;
} /* int tss2_send_request */
static int tss2_receive_line(FILE *fh, char *buffer, int buffer_size) {
ERROR("teamspeak2 plugin: fgets failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
tss2_close_socket();
- return (-1);
+ return -1;
}
buffer[buffer_size - 1] = 0;
- return (0);
+ return 0;
} /* int tss2_receive_line */
static int tss2_select_vserver(FILE *read_fh, FILE *write_fh,
status = tss2_send_request(write_fh, command);
if (status != 0) {
ERROR("teamspeak2 plugin: tss2_send_request (%s) failed.", command);
- return (-1);
+ return -1;
}
/* Get answer */
status = tss2_receive_line(read_fh, response, sizeof(response));
if (status != 0) {
ERROR("teamspeak2 plugin: tss2_receive_line failed.");
- return (-1);
+ return -1;
}
response[sizeof(response) - 1] = 0;
/* Check answer */
if ((strncasecmp("OK", response, 2) == 0) &&
((response[2] == 0) || (response[2] == '\n') || (response[2] == '\r')))
- return (0);
+ return 0;
ERROR("teamspeak2 plugin: Command ``%s'' failed. "
"Response received from server was: ``%s''.",
command, response);
- return (-1);
+ return -1;
} /* int tss2_select_vserver */
static int tss2_vserver_gapl(FILE *read_fh, FILE *write_fh,
status = tss2_send_request(write_fh, "gapl\r\n");
if (status != 0) {
ERROR("teamspeak2 plugin: tss2_send_request (gapl) failed.");
- return (-1);
+ return -1;
}
while (42) {
read_fh = NULL;
write_fh = NULL;
ERROR("teamspeak2 plugin: tss2_receive_line failed.");
- return (-1);
+ return -1;
}
buffer[sizeof(buffer) - 1] = 0;
break;
} else if (strncasecmp("ERROR", buffer, 5) == 0) {
ERROR("teamspeak2 plugin: Server returned an error: %s", buffer);
- return (-1);
+ return -1;
} else {
WARNING("teamspeak2 plugin: Server returned unexpected string: %s",
buffer);
}
*ret_value = packet_loss;
- return (0);
+ return 0;
} /* int tss2_vserver_gapl */
static int tss2_read_vserver(vserver_list_t *vserver) {
status = tss2_get_socket(&read_fh, &write_fh);
if (status != 0) {
ERROR("teamspeak2 plugin: tss2_get_socket failed.");
- return (-1);
+ return -1;
}
if (vserver == NULL) {
/* Select the server */
status = tss2_select_vserver(read_fh, write_fh, vserver);
if (status != 0)
- return (status);
+ return status;
status = tss2_send_request(write_fh, "si\r\n");
}
if (status != 0) {
ERROR("teamspeak2 plugin: tss2_send_request failed.");
- return (-1);
+ return -1;
}
/* Loop until break */
tss2_submit_gauge(plugin_instance, "gauge", "servers", servers);
if (valid == 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
} /* int tss2_read_vserver */
static int tss2_config(const char *key, const char *value) {
temp = strdup(value);
if (temp == NULL) {
ERROR("teamspeak2 plugin: strdup failed.");
- return (1);
+ return 1;
}
sfree(config_host);
config_host = temp;
temp = strdup(value);
if (temp == NULL) {
ERROR("teamspeak2 plugin: strdup failed.");
- return (1);
+ return 1;
}
sfree(config_port);
config_port = temp;
status = tss2_add_vserver(atoi(value));
if (status != 0)
- return (1);
+ return 1;
} else {
/* Unknown variable found */
- return (-1);
+ return -1;
}
return 0;
}
if (success == 0)
- return (-1);
- return (0);
+ return -1;
+ return 0;
} /* int tss2_read */
static int tss2_shutdown(void) {
sfree(config_host);
sfree(config_port);
- return (0);
+ return 0;
} /* int tss2_shutdown */
void module_register(void) {
diff --git a/src/ted.c b/src/ted.c
index fbfd95dbd78680f9b121d533501e13323519ebe3..94b4e3ab4b6dc9112282969b509d852627dbad74 100644 (file)
--- a/src/ted.c
+++ b/src/ted.c
status = write(fd, pkt_request, sizeof(pkt_request));
if (status <= 0) {
ERROR("ted plugin: swrite failed.");
- return (-1);
+ return -1;
}
/* Loop until we find the end of the package */
{
WARNING("ted plugin: Timeout while waiting for file descriptor "
"to become ready.");
- return (-1);
+ return -1;
} else if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR))) {
/* Some signal or something. Start over.. */
continue;
char errbuf[1024];
ERROR("ted plugin: select failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
receive_buffer_length = read(fd, receive_buffer, sizeof(receive_buffer));
continue;
ERROR("ted plugin: read(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
} else if (receive_buffer_length == 0) {
/* Should we close the FD in this case? */
WARNING("ted plugin: Received EOF from file descriptor.");
- return (-1);
+ return -1;
} else if (((size_t)receive_buffer_length) > sizeof(receive_buffer)) {
ERROR("ted plugin: read(2) returned invalid value %zi.",
receive_buffer_length);
- return (-1);
+ return -1;
}
/*
/* Check for errors inside the loop. */
if ((end_flag == 0) || (package_buffer_pos != EXPECTED_PACKAGE_LENGTH))
- return (-1);
+ return -1;
/*
* Power is at positions 247 and 248 (LSB first) in [10kW].
((int)package_buffer[251]));
/* success */
- return (0);
+ return 0;
} /* int ted_read_value */
static int ted_open_device(void) {
struct termios options;
if (fd >= 0)
- return (0);
+ return 0;
dev = DEFAULT_DEVICE;
if (conf_device != NULL)
fd = open(dev, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
if (fd < 0) {
ERROR("ted plugin: Unable to open device %s.", dev);
- return (-1);
+ return -1;
}
/* Get the current options for the port... */
tcsetattr(fd, TCSANOW, &options);
INFO("ted plugin: Successfully opened %s.", dev);
- return (0);
+ return 0;
} /* int ted_open_device */
static void ted_submit(const char *type, double value) {
tmp = atoi(value);
if (tmp < 0) {
WARNING("ted plugin: Invalid retry count: %i", tmp);
- return (1);
+ return 1;
}
conf_retries = tmp;
} else {
ERROR("ted plugin: Unknown config option: %s", key);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int ted_config */
static int ted_read(void) {
status = ted_open_device();
if (status != 0)
- return (-1);
+ return -1;
power = NAN;
voltage = NAN;
}
if (status != 0)
- return (-1);
+ return -1;
ted_submit("power", power);
ted_submit("voltage", voltage);
- return (0);
+ return 0;
} /* int ted_read */
static int ted_shutdown(void) {
fd = -1;
}
- return (0);
+ return 0;
} /* int ted_shutdown */
void module_register(void) {
diff --git a/src/testing.h b/src/testing.h
index 42f45ce6a71a989d9a30ca9497f7b13c516ce96e..a89f46298f5a87d8c0b671c163f0a76928aed70b 100644 (file)
--- a/src/testing.h
+++ b/src/testing.h
if (strcmp(expect, got__) != 0) { \
printf("not ok %i - %s = \"%s\", want \"%s\"\n", ++check_count__, \
#actual, got__, expect); \
- return (-1); \
+ return -1; \
} \
printf("ok %i - %s = \"%s\"\n", ++check_count__, #actual, got__); \
} while (0)
if (got__ != want__) { \
printf("not ok %i - %s = %d, want %d\n", ++check_count__, #actual, \
got__, want__); \
- return (-1); \
+ return -1; \
} \
printf("ok %i - %s = %d\n", ++check_count__, #actual, got__); \
} while (0)
if (got__ != want__) { \
printf("not ok %i - %s = %" PRIu64 ", want %" PRIu64 "\n", \
++check_count__, #actual, got__, want__); \
- return (-1); \
+ return -1; \
} \
printf("ok %i - %s = %" PRIu64 "\n", ++check_count__, #actual, got__); \
} while (0)
if (isnan(want__) && !isnan(got__)) { \
printf("not ok %i - %s = %.15g, want %.15g\n", ++check_count__, #actual, \
got__, want__); \
- return (-1); \
+ return -1; \
} else if (!isnan(want__) && (((want__ - got__) < -DBL_PRECISION) || \
((want__ - got__) > DBL_PRECISION))) { \
printf("not ok %i - %s = %.15g, want %.15g\n", ++check_count__, #actual, \
got__, want__); \
- return (-1); \
+ return -1; \
} \
printf("ok %i - %s = %.15g\n", ++check_count__, #actual, got__); \
} while (0)
diff --git a/src/thermal.c b/src/thermal.c
index fbae6cc1e686ec177e9dbceaa71f9f99754c5ea9..48157552eed1dff67d7b9a8c9d0388b7f0b05126 100644 (file)
--- a/src/thermal.c
+++ b/src/thermal.c
success = 1;
}
- return (success ? 0 : -1);
+ return success ? 0 : -1;
}
static int thermal_procfs_device_read(const char __attribute__((unused)) * dir,
}
static int thermal_sysfs_read(void) {
- return walk_directory(dirname_sysfs, thermal_sysfs_device_read,
- /* user_data = */ NULL, /* include hidden */ 0);
+ return walk_directory(dirname_sysfs, thermal_sysfs_device_read, NULL, 0);
}
static int thermal_procfs_read(void) {
- return walk_directory(dirname_procfs, thermal_procfs_device_read,
- /* user_data = */ NULL, /* include hidden */ 0);
+ return walk_directory(dirname_procfs, thermal_procfs_device_read, NULL, 0);
}
static int thermal_init(void) {
diff --git a/src/threshold.c b/src/threshold.c
index a4a999f571ee899c056df0ef0396b4619deece54..72e922e90583b0e5ba2dfce2191800f3b11f06e5 100644 (file)
--- a/src/threshold.c
+++ b/src/threshold.c
if (format_name(name, sizeof(name), th->host, th->plugin, th->plugin_instance,
th->type, th->type_instance) != 0) {
ERROR("ut_threshold_add: format_name failed.");
- return (-1);
+ return -1;
}
name_copy = strdup(name);
if (name_copy == NULL) {
ERROR("ut_threshold_add: strdup failed.");
- return (-1);
+ return -1;
}
th_copy = malloc(sizeof(*th_copy));
if (th_copy == NULL) {
sfree(name_copy);
ERROR("ut_threshold_add: malloc failed.");
- return (-1);
+ return -1;
}
memcpy(th_copy, th, sizeof(threshold_t));
sfree(th_copy);
}
- return (status);
+ return status;
} /* }}} int ut_threshold_add */
/*
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("threshold values: The `DataSource' option needs exactly one "
"string argument.");
- return (-1);
+ return -1;
}
sstrncpy(th->data_source, ci->values[0].value.string,
sizeof(th->data_source));
- return (0);
+ return 0;
} /* int ut_config_type_datasource */
static int ut_config_type_instance(threshold_t *th, oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("threshold values: The `Instance' option needs exactly one "
"string argument.");
- return (-1);
+ return -1;
}
sstrncpy(th->type_instance, ci->values[0].value.string,
sizeof(th->type_instance));
- return (0);
+ return 0;
} /* int ut_config_type_instance */
static int ut_config_type_max(threshold_t *th, oconfig_item_t *ci) {
WARNING("threshold values: The `%s' option needs exactly one "
"number argument.",
ci->key);
- return (-1);
+ return -1;
}
if (strcasecmp(ci->key, "WarningMax") == 0)
else
th->failure_max = ci->values[0].value.number;
- return (0);
+ return 0;
} /* int ut_config_type_max */
static int ut_config_type_min(threshold_t *th, oconfig_item_t *ci) {
WARNING("threshold values: The `%s' option needs exactly one "
"number argument.",
ci->key);
- return (-1);
+ return -1;
}
if (strcasecmp(ci->key, "WarningMin") == 0)
else
th->failure_min = ci->values[0].value.number;
- return (0);
+ return 0;
} /* int ut_config_type_min */
static int ut_config_type_hits(threshold_t *th, oconfig_item_t *ci) {
WARNING("threshold values: The `%s' option needs exactly one "
"number argument.",
ci->key);
- return (-1);
+ return -1;
}
th->hits = ci->values[0].value.number;
- return (0);
+ return 0;
} /* int ut_config_type_hits */
static int ut_config_type_hysteresis(threshold_t *th, oconfig_item_t *ci) {
WARNING("threshold values: The `%s' option needs exactly one "
"number argument.",
ci->key);
- return (-1);
+ return -1;
}
th->hysteresis = ci->values[0].value.number;
- return (0);
+ return 0;
} /* int ut_config_type_hysteresis */
static int ut_config_type(const threshold_t *th_orig, oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("threshold values: The `Type' block needs exactly one string "
"argument.");
- return (-1);
+ return -1;
}
if (ci->children_num < 1) {
WARNING("threshold values: The `Type' block needs at least one option.");
- return (-1);
+ return -1;
}
memcpy(&th, th_orig, sizeof(th));
status = ut_threshold_add(&th);
}
- return (status);
+ return status;
} /* int ut_config_type */
static int ut_config_plugin_instance(threshold_t *th, oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("threshold values: The `Instance' option needs exactly one "
"string argument.");
- return (-1);
+ return -1;
}
sstrncpy(th->plugin_instance, ci->values[0].value.string,
sizeof(th->plugin_instance));
- return (0);
+ return 0;
} /* int ut_config_plugin_instance */
static int ut_config_plugin(const threshold_t *th_orig, oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("threshold values: The `Plugin' block needs exactly one string "
"argument.");
- return (-1);
+ return -1;
}
if (ci->children_num < 1) {
WARNING("threshold values: The `Plugin' block needs at least one nested "
"block.");
- return (-1);
+ return -1;
}
memcpy(&th, th_orig, sizeof(th));
break;
}
- return (status);
+ return status;
} /* int ut_config_plugin */
static int ut_config_host(const threshold_t *th_orig, oconfig_item_t *ci) {
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("threshold values: The `Host' block needs exactly one string "
"argument.");
- return (-1);
+ return -1;
}
if (ci->children_num < 1) {
WARNING("threshold values: The `Host' block needs at least one nested "
"block.");
- return (-1);
+ return -1;
}
memcpy(&th, th_orig, sizeof(th));
break;
}
- return (status);
+ return status;
} /* int ut_config_host */
/*
* End of the functions used to configure threshold values.
DEBUG("ut_report_state: th->hits = %d, uc_get_hits = %d", th->hits,
uc_get_hits(ds, vl));
(void)uc_inc_hits(ds, vl, 1); /* increase hit counter */
- return (0);
+ return 0;
}
} /* end check hits */
* state is `okay', then only report if `persist_ok` flag is set. */
if (state == state_old) {
if ((th->flags & UT_FLAG_PERSIST) == 0)
- return (0);
+ return 0;
else if ((state == STATE_OKAY) && ((th->flags & UT_FLAG_PERSIST_OK) == 0))
- return (0);
+ return 0;
}
if (state != state_old)
plugin_dispatch_notification(&n);
plugin_notification_meta_free(n.meta);
- return (0);
+ return 0;
} /* }}} int ut_report_state */
/*
if (ds != NULL) {
ds_name = ds->ds[ds_index].name;
if ((th->data_source[0] != 0) && (strcmp(ds_name, th->data_source) != 0))
- return (STATE_OKAY);
+ return STATE_OKAY;
}
if ((th->flags & UT_FLAG_INVERT) != 0) {
}
if (is_failure != 0)
- return (STATE_ERROR);
+ return STATE_ERROR;
if (is_warning != 0)
- return (STATE_WARNING);
+ return STATE_WARNING;
- return (STATE_OKAY);
+ return STATE_OKAY;
} /* }}} int ut_check_one_data_source */
/*
if (ret_ds_index != NULL)
*ret_ds_index = ds_index;
- return (ret);
+ return ret;
} /* }}} int ut_check_one_threshold */
/*
int worst_ds_index = -1;
if (threshold_tree == NULL)
- return (0);
+ return 0;
/* Is this lock really necessary? So far, thresholds are only inserted at
* startup. -octo */
th = threshold_search(vl);
pthread_mutex_unlock(&threshold_lock);
if (th == NULL)
- return (0);
+ return 0;
DEBUG("ut_check_threshold: Found matching threshold(s)");
values = uc_get_rate(ds, vl);
if (values == NULL)
- return (0);
+ return 0;
while (th != NULL) {
int ds_index = -1;
if (status < 0) {
ERROR("ut_check_threshold: ut_check_one_threshold failed.");
sfree(values);
- return (-1);
+ return -1;
}
if (worst_state < status) {
if (status != 0) {
ERROR("ut_check_threshold: ut_report_state failed.");
sfree(values);
- return (-1);
+ return -1;
}
sfree(values);
- return (0);
+ return 0;
} /* }}} int ut_check_threshold */
/*
cdtime_t now;
if (threshold_tree == NULL)
- return (0);
+ return 0;
th = threshold_search(vl);
/* dispatch notifications for "interesting" values only */
if ((th == NULL) || ((th->flags & UT_FLAG_INTERESTING) == 0))
- return (0);
+ return 0;
now = cdtime();
missing_time = now - vl->time;
plugin_dispatch_notification(&n);
- return (0);
+ return 0;
} /* }}} int ut_missing */
static int ut_config(oconfig_item_t *ci) { /* {{{ */
threshold_tree = c_avl_create((int (*)(const void *, const void *))strcmp);
if (threshold_tree == NULL) {
ERROR("ut_config: c_avl_create failed.");
- return (-1);
+ return -1;
}
}
/* user data = */ NULL);
}
- return (status);
+ return status;
} /* }}} int um_config */
void module_register(void) {
diff --git a/src/tokyotyrant.c b/src/tokyotyrant.c
index 09ee25d72f115b1ed09e5d02ce7abf549b326d26..1534f51efa21a402f376a0ecead0009dc25b1467 100644 (file)
--- a/src/tokyotyrant.c
+++ b/src/tokyotyrant.c
temp = strdup(value);
if (temp == NULL) {
ERROR("tokyotyrant plugin: Host strdup failed.");
- return (1);
+ return 1;
}
sfree(config_host);
config_host = temp;
temp = strdup(value);
if (temp == NULL) {
ERROR("tokyotyrant plugin: Port strdup failed.");
- return (1);
+ return 1;
}
sfree(config_port);
config_port = temp;
} else {
ERROR("tokyotyrant plugin: error: unrecognized configuration key %s", key);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
static void printerr(void) {
tt_open_db();
if (rdb == NULL)
- return (-1);
+ return -1;
rnum = tcrdbrnum(rdb);
tt_submit(rnum, "records");
size = tcrdbsize(rdb);
tt_submit(size, "file_size");
- return (0);
+ return 0;
}
static int tt_shutdown(void) {
if (!tcrdbclose(rdb)) {
printerr();
tcrdbdel(rdb);
- return (1);
+ return 1;
}
tcrdbdel(rdb);
rdb = NULL;
}
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/turbostat.c b/src/turbostat.c
index 62bd92b13bda49efbdc83b702866fc0b164a6385..45c8bd704537206ae78058186b589dba09e3d0ea 100644 (file)
--- a/src/turbostat.c
+++ b/src/turbostat.c
retval = func(cpu_num);
if (retval) {
fclose(fp);
- return (retval);
+ return retval;
}
}
fclose(fp);
diff --git a/src/unixsock.c b/src/unixsock.c
index b08c89f11d6812016d68ddba8f672ca8adba71fd..8ccde80b9342e1c4aac0f6af4d24a1e6dbc1db34 100644 (file)
--- a/src/unixsock.c
+++ b/src/unixsock.c
char errbuf[1024];
ERROR("unixsock plugin: socket failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
sa.sun_family = AF_UNIX;
ERROR("unixsock plugin: bind failed: %s", errbuf);
close(sock_fd);
sock_fd = -1;
- return (-1);
+ return -1;
}
status = chmod(sa.sun_path, sock_perms);
sstrerror(errno, errbuf, sizeof(errbuf)));
close(sock_fd);
sock_fd = -1;
- return (-1);
+ return -1;
}
status = listen(sock_fd, 8);
sstrerror(errno, errbuf, sizeof(errbuf)));
close(sock_fd);
sock_fd = -1;
- return (-1);
+ return -1;
}
do {
}
} while (0);
- return (0);
+ return 0;
} /* int us_open_socket */
static void *us_handle_client(void *arg) {
close(fdin);
close(fdout);
pthread_exit((void *)1);
- return ((void *)1);
+ return (void *)1;
}
fhout = fdopen(fdout, "w");
fclose(fhin); /* this closes fdin as well */
close(fdout);
pthread_exit((void *)1);
- return ((void *)1);
+ return (void *)1;
}
/* change output buffer to line buffered mode */
fclose(fhin);
fclose(fhout);
pthread_exit((void *)1);
- return ((void *)0);
+ return (void *)0;
}
while (42) {
fclose(fhin);
fclose(fhout);
pthread_exit((void *)1);
- return ((void *)1);
+ return (void *)1;
}
if (strcasecmp(fields[0], "getval") == 0) {
fclose(fhout);
pthread_exit((void *)0);
- return ((void *)0);
+ return (void *)0;
} /* void *us_handle_client */
static void *us_server_thread(void __attribute__((unused)) * arg) {
sstrerror(errno, errbuf, sizeof(errbuf)));
}
- return ((void *)0);
+ return (void *)0;
} /* void *us_server_thread */
static int us_config(const char *key, const char *val) {
if (strcasecmp(key, "SocketFile") == 0) {
char *new_sock_file = strdup(val);
if (new_sock_file == NULL)
- return (1);
+ return 1;
sfree(sock_file);
sock_file = new_sock_file;
} else if (strcasecmp(key, "SocketGroup") == 0) {
char *new_sock_group = strdup(val);
if (new_sock_group == NULL)
- return (1);
+ return 1;
sfree(sock_group);
sock_group = new_sock_group;
else
delete_socket = 0;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int us_config */
static int us_init(void) {
/* Initialize only once. */
if (have_init != 0)
- return (0);
+ return 0;
have_init = 1;
loop = 1;
char errbuf[1024];
ERROR("unixsock plugin: pthread_create failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int us_init */
static int us_shutdown(void) {
plugin_unregister_init("unixsock");
plugin_unregister_shutdown("unixsock");
- return (0);
+ return 0;
} /* int us_shutdown */
void module_register(void) {
diff --git a/src/uptime.c b/src/uptime.c
index 96a227d99afd54434b6fe9f88841ab3c820b017c..2be9d79da0d793af64685c8171da2a29887b5edd 100644 (file)
--- a/src/uptime.c
+++ b/src/uptime.c
char errbuf[1024];
ERROR("uptime plugin: Cannot open " STAT_FILE ": %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, 1024, fh) != NULL) {
/* loop done, check if no value has been found/read */
if (ret != 1) {
ERROR("uptime plugin: No value read from " STAT_FILE "");
- return (-1);
+ return -1;
}
boottime = (time_t)starttime;
if (boottime == 0) {
ERROR("uptime plugin: btime read from " STAT_FILE ", "
"but `boottime' is zero!");
- return (-1);
+ return -1;
}
/* #endif KERNEL_LINUX */
* went fine. */
if (kc == NULL) {
ERROR("uptime plugin: kstat chain control structure not available.");
- return (-1);
+ return -1;
}
ksp = kstat_lookup(kc, "unix", 0, "system_misc");
if (ksp == NULL) {
ERROR("uptime plugin: Cannot find unix:0:system_misc kstat.");
- return (-1);
+ return -1;
}
if (kstat_read(kc, ksp, NULL) < 0) {
ERROR("uptime plugin: kstat_read failed.");
- return (-1);
+ return -1;
}
knp = (kstat_named_t *)kstat_data_lookup(ksp, "boot_time");
if (knp == NULL) {
ERROR("uptime plugin: kstat_data_lookup (boot_time) failed.");
- return (-1);
+ return -1;
}
boottime = (time_t)knp->value.ui32;
if (boottime == 0) {
ERROR("uptime plugin: kstat_data_lookup returned success, "
"but `boottime' is zero!");
- return (-1);
+ return -1;
}
/* #endif HAVE_LIBKSTAT */
char errbuf[1024];
ERROR("uptime plugin: No value read from sysctl interface: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
boottime = boottv.tv_sec;
if (boottime == 0) {
ERROR("uptime plugin: sysctl(3) returned success, "
"but `boottime' is zero!");
- return (-1);
+ return -1;
}
/* #endif HAVE_SYS_SYSCTL_H */
char errbuf[1024];
ERROR("uptime plugin: perfstat_cpu_total: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
hertz = sysconf(_SC_CLK_TCK);
boottime = time(NULL) - cputotal.lbolt / hertz;
#endif /* HAVE_PERFSTAT */
- return (0);
+ return 0;
} /* }}} int uptime_init */
static int uptime_read(void) {
uptime_submit(uptime);
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/users.c b/src/users.c
index ff8c047adb8aae105f27b8d774171e238bd7de88..6bc7cc34e79f680316862f40b9780b0c010c801b 100644 (file)
--- a/src/users.c
+++ b/src/users.c
us = sg_get_user_stats();
#endif
if (us == NULL)
- return (-1);
+ return -1;
users_submit((gauge_t)
#if HAVE_LIBSTATGRAB_0_90
#error "No applicable input method."
#endif
- return (0);
+ return 0;
} /* int users_read */
void module_register(void) {
diff --git a/src/utils_cmd_flush.c b/src/utils_cmd_flush.c
index 25a55122bea82f545a376dd8ceb336fd62a80480..b180a5019780e037ab2c90e86581f0eb90af1fcc 100644 (file)
--- a/src/utils_cmd_flush.c
+++ b/src/utils_cmd_flush.c
if ((ret_flush == NULL) || (opts == NULL)) {
errno = EINVAL;
cmd_error(CMD_ERROR, err, "Invalid arguments to cmd_parse_flush.");
- return (CMD_ERROR);
+ return CMD_ERROR;
}
for (size_t i = 0; i < argc; i++) {
if (status == CMD_NO_OPTION)
cmd_error(CMD_PARSE_ERROR, err, "Invalid option string `%s'.", argv[i]);
cmd_destroy_flush(ret_flush);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
if (strcasecmp("plugin", opt_key) == 0) {
if (id == NULL) {
cmd_error(CMD_ERROR, err, "realloc failed.");
cmd_destroy_flush(ret_flush);
- return (CMD_ERROR);
+ return CMD_ERROR;
}
ret_flush->identifiers = id;
opts->identifier_default_host) != 0) {
cmd_error(CMD_PARSE_ERROR, err, "Invalid identifier `%s'.", opt_value);
cmd_destroy_flush(ret_flush);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
} else if (strcasecmp("timeout", opt_key) == 0) {
char *endptr;
cmd_error(CMD_PARSE_ERROR, err,
"Invalid value for option `timeout': %s", opt_value);
cmd_destroy_flush(ret_flush);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
} else if (ret_flush->timeout < 0.0) {
ret_flush->timeout = 0.0;
}
} else {
cmd_error(CMD_PARSE_ERROR, err, "Cannot parse option `%s'.", opt_key);
cmd_destroy_flush(ret_flush);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
}
- return (CMD_OK);
+ return CMD_OK;
} /* cmd_status_t cmd_parse_flush */
cmd_status_t cmd_handle_flush(FILE *fh, char *buffer) {
int status;
if ((fh == NULL) || (buffer == NULL))
- return (-1);
+ return -1;
DEBUG("utils_cmd_flush: cmd_handle_flush (fh = %p, buffer = %s);", (void *)fh,
buffer);
if ((status = cmd_parse(buffer, &cmd, NULL, &err)) != CMD_OK)
- return (status);
+ return status;
if (cmd.type != CMD_FLUSH) {
cmd_error(CMD_UNKNOWN_COMMAND, &err, "Unexpected command: `%s'.",
CMD_TO_STRING(cmd.type));
cmd_destroy(&cmd);
- return (CMD_UNKNOWN_COMMAND);
+ return CMD_UNKNOWN_COMMAND;
}
for (size_t i = 0; (i == 0) || (i < cmd.cmd.flush.plugins_num); i++) {
cmd_error(CMD_OK, &err, "Done: %i successful, %i errors", success, error);
cmd_destroy(&cmd);
- return (0);
+ return 0;
#undef PRINT_TO_SOCK
} /* cmd_status_t cmd_handle_flush */
index 063548b7777ea2430ade32b4b1e25e20d7a7e64a..78f9a75ab0b0c1da92f40b295ec6d751ff1c2573 100644 (file)
size_t i;
if ((fh == NULL) || (buffer == NULL))
- return (-1);
+ return -1;
DEBUG("utils_cmd_getthreshold: handle_getthreshold (fh = %p, buffer = %s);",
(void *)fh, buffer);
status = parse_string(&buffer, &command);
if (status != 0) {
print_to_socket(fh, "-1 Cannot parse command.\n");
- return (-1);
+ return -1;
}
assert(command != NULL);
if (strcasecmp("GETTHRESHOLD", command) != 0) {
print_to_socket(fh, "-1 Unexpected command: `%s'.\n", command);
- return (-1);
+ return -1;
}
identifier = NULL;
status = parse_string(&buffer, &identifier);
if (status != 0) {
print_to_socket(fh, "-1 Cannot parse identifier.\n");
- return (-1);
+ return -1;
}
assert(identifier != NULL);
if (*buffer != 0) {
print_to_socket(fh, "-1 Garbage after end of command: %s\n", buffer);
- return (-1);
+ return -1;
}
/* parse_identifier() modifies its first argument,
DEBUG("handle_getthreshold: Cannot parse identifier `%s'.", identifier);
print_to_socket(fh, "-1 Cannot parse identifier `%s'.\n", identifier);
sfree(identifier_copy);
- return (-1);
+ return -1;
}
value_list_t vl = {.values = NULL};
if (status == ENOENT) {
print_to_socket(fh, "-1 No threshold found for identifier %s\n",
identifier);
- return (0);
+ return 0;
} else if (status != 0) {
print_to_socket(fh, "-1 Error while looking up threshold: %i\n", status);
- return (-1);
+ return -1;
}
/* Lets count the number of lines we'll return. */
if (threshold.hits > 1)
print_to_socket(fh, "Hits: %i\n", threshold.hits);
- return (0);
+ return 0;
} /* int handle_getthreshold */
diff --git a/src/utils_cmd_getval.c b/src/utils_cmd_getval.c
index e5f17b634f890206b8b23a6a52d5653db8088db5..59046f6944cbe9d5c6fbdee1774843f71eddfdbf 100644 (file)
--- a/src/utils_cmd_getval.c
+++ b/src/utils_cmd_getval.c
if ((ret_getval == NULL) || (opts == NULL)) {
errno = EINVAL;
cmd_error(CMD_ERROR, err, "Invalid arguments to cmd_parse_getval.");
- return (CMD_ERROR);
+ return CMD_ERROR;
}
if (argc != 1) {
else
cmd_error(CMD_PARSE_ERROR, err, "Garbage after identifier: `%s'.",
argv[1]);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
/* parse_identifier() modifies its first argument,
cmd_error(CMD_PARSE_ERROR, err, "Cannot parse identifier `%s'.",
identifier_copy);
sfree(identifier_copy);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
ret_getval->raw_identifier = identifier_copy;
- return (CMD_OK);
+ return CMD_OK;
} /* cmd_status_t cmd_parse_getval */
#define print_to_socket(fh, ...) \
const data_set_t *ds;
if ((fh == NULL) || (buffer == NULL))
- return (-1);
+ return -1;
DEBUG("utils_cmd_getval: cmd_handle_getval (fh = %p, buffer = %s);",
(void *)fh, buffer);
if ((status = cmd_parse(buffer, &cmd, NULL, &err)) != CMD_OK)
- return (status);
+ return status;
if (cmd.type != CMD_GETVAL) {
cmd_error(CMD_UNKNOWN_COMMAND, &err, "Unexpected command: `%s'.",
CMD_TO_STRING(cmd.type));
cmd_destroy(&cmd);
- return (CMD_UNKNOWN_COMMAND);
+ return CMD_UNKNOWN_COMMAND;
}
ds = plugin_get_ds(cmd.cmd.getval.identifier.type);
cmd_error(CMD_ERROR, &err, "Type `%s' is unknown.\n",
cmd.cmd.getval.identifier.type);
cmd_destroy(&cmd);
- return (-1);
+ return -1;
}
values = NULL;
if (status != 0) {
cmd_error(CMD_ERROR, &err, "No such value.");
cmd_destroy(&cmd);
- return (CMD_ERROR);
+ return CMD_ERROR;
}
if (ds->ds_num != values_num) {
cmd_error(CMD_ERROR, &err, "Error reading value from cache.");
sfree(values);
cmd_destroy(&cmd);
- return (CMD_ERROR);
+ return CMD_ERROR;
}
print_to_socket(fh, "%zu Value%s found\n", values_num,
sfree(values);
cmd_destroy(&cmd);
- return (CMD_OK);
+ return CMD_OK;
} /* cmd_status_t cmd_handle_getval */
void cmd_destroy_getval(cmd_getval_t *getval) {
index 4e603a2f963bcc2ed3fe32c6aac2f9b6fa6df8a7..36406305e4018df7b293138e2d6ad825ebdd6ff4 100644 (file)
--- a/src/utils_cmd_listval.c
+++ b/src/utils_cmd_listval.c
if (argc != 0) {
cmd_error(CMD_PARSE_ERROR, err, "Garbage after end of command: `%s'.",
argv[0]);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
- return (CMD_OK);
+ return CMD_OK;
} /* cmd_status_t cmd_parse_listval */
#define free_everything_and_return(status) \
} \
sfree(names); \
sfree(times); \
- return (status); \
+ return status; \
} while (0)
#define print_to_socket(fh, ...) \
buffer);
if ((status = cmd_parse(buffer, &cmd, NULL, &err)) != CMD_OK)
- return (status);
+ return status;
if (cmd.type != CMD_LISTVAL) {
cmd_error(CMD_UNKNOWN_COMMAND, &err, "Unexpected command: `%s'.",
CMD_TO_STRING(cmd.type));
index 8f687fd8a8421d2fd4fa36e12cbde8493129fa9f..0085c62bc204aca55f9fd2ad5b8f1469f81c39d6 100644 (file)
--- a/src/utils_cmd_putnotif.c
+++ b/src/utils_cmd_putnotif.c
else if (strcasecmp(value, "Okay") == 0)
n->severity = NOTIF_OKAY;
else
- return (-1);
+ return -1;
- return (0);
+ return 0;
} /* int set_option_severity */
static int set_option_time(notification_t *n, const char *value) {
|| (endptr == value) /* Invalid string */
|| (endptr == NULL) /* This should not happen */
|| (*endptr != 0)) /* Trailing chars */
- return (-1);
+ return -1;
n->time = DOUBLE_TO_CDTIME_T(tmp);
- return (0);
+ return 0;
} /* int set_option_time */
static int set_option(notification_t *n, const char *option,
const char *value) {
if ((n == NULL) || (option == NULL) || (value == NULL))
- return (-1);
+ return -1;
DEBUG("utils_cmd_putnotif: set_option (option = %s, value = %s);", option,
value);
if (option[0] != '\0' && option[1] == ':') {
/* Refuse empty key */
if (option[2] == '\0')
- return (1);
+ return 1;
if (option[0] == 's')
return plugin_notification_meta_add_string(n, option + 2, value);
else
- return (1);
+ return 1;
}
if (strcasecmp("severity", option) == 0)
- return (set_option_severity(n, value));
+ return set_option_severity(n, value);
else if (strcasecmp("time", option) == 0)
- return (set_option_time(n, value));
+ return set_option_time(n, value);
else if (strcasecmp("message", option) == 0)
sstrncpy(n->message, value, sizeof(n->message));
else if (strcasecmp("host", option) == 0)
else if (strcasecmp("type_instance", option) == 0)
sstrncpy(n->type_instance, value, sizeof(n->type_instance));
else
- return (1);
+ return 1;
- return (0);
+ return 0;
} /* int set_option */
int handle_putnotif(FILE *fh, char *buffer) {
int status;
if ((fh == NULL) || (buffer == NULL))
- return (-1);
+ return -1;
DEBUG("utils_cmd_putnotif: handle_putnotif (fh = %p, buffer = %s);",
(void *)fh, buffer);
status = parse_string(&buffer, &command);
if (status != 0) {
print_to_socket(fh, "-1 Cannot parse command.\n");
- return (-1);
+ return -1;
}
assert(command != NULL);
if (strcasecmp("PUTNOTIF", command) != 0) {
print_to_socket(fh, "-1 Unexpected command: `%s'.\n", command);
- return (-1);
+ return -1;
}
status = 0;
print_to_socket(fh, "0 Success\n");
}
- return (0);
+ return 0;
} /* int handle_putnotif */
diff --git a/src/utils_cmd_putval.c b/src/utils_cmd_putval.c
index f1fe6d767bb50eacbed6ec063062dbc16529d1f8..718425b08eb5bf66fdc5c93596c9f0fa8b8e48b2 100644 (file)
--- a/src/utils_cmd_putval.c
+++ b/src/utils_cmd_putval.c
static int set_option(value_list_t *vl, const char *key, const char *value) {
if ((vl == NULL) || (key == NULL) || (value == NULL))
- return (-1);
+ return -1;
if (strcasecmp("interval", key) == 0) {
double tmp;
if ((errno == 0) && (endptr != NULL) && (endptr != value) && (tmp > 0.0))
vl->interval = DOUBLE_TO_CDTIME_T(tmp);
} else
- return (1);
+ return 1;
- return (0);
+ return 0;
} /* int set_option */
/*
if ((ret_putval == NULL) || (opts == NULL)) {
errno = EINVAL;
cmd_error(CMD_ERROR, err, "Invalid arguments to cmd_parse_putval.");
- return (CMD_ERROR);
+ return CMD_ERROR;
}
if (argc < 2) {
cmd_error(CMD_PARSE_ERROR, err, "Missing identifier and/or value-list.");
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
identifier = argv[0];
cmd_error(CMD_PARSE_ERROR, err, "Cannot parse identifier `%s'.",
identifier_copy);
sfree(identifier_copy);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
if ((strlen(hostname) >= sizeof(vl.host)) ||
(strlen(type_instance) >= sizeof(vl.type_instance)))) {
cmd_error(CMD_PARSE_ERROR, err, "Identifier too long.");
sfree(identifier_copy);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
sstrncpy(vl.host, hostname, sizeof(vl.host));
if (ds == NULL) {
cmd_error(CMD_PARSE_ERROR, err, "1 Type `%s' isn't defined.", type);
sfree(identifier_copy);
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
hostname = NULL;
cmd_error(CMD_ERROR, err, "malloc failed.");
cmd_destroy_putval(ret_putval);
sfree(vl.values);
- return (CMD_ERROR);
+ return CMD_ERROR;
}
/* All the remaining fields are part of the option list. */
if (result != CMD_OK)
cmd_destroy_putval(ret_putval);
- return (result);
+ return result;
} /* cmd_status_t cmd_parse_putval */
void cmd_destroy_putval(cmd_putval_t *putval) {
(void *)fh, buffer);
if ((status = cmd_parse(buffer, &cmd, NULL, &err)) != CMD_OK)
- return (status);
+ return status;
if (cmd.type != CMD_PUTVAL) {
cmd_error(CMD_UNKNOWN_COMMAND, &err, "Unexpected command: `%s'.",
CMD_TO_STRING(cmd.type));
cmd_destroy(&cmd);
- return (CMD_UNKNOWN_COMMAND);
+ return CMD_UNKNOWN_COMMAND;
}
for (size_t i = 0; i < cmd.cmd.putval.vl_num; ++i)
(cmd.cmd.putval.vl_num == 1) ? "value has" : "values have");
cmd_destroy(&cmd);
- return (CMD_OK);
+ return CMD_OK;
} /* int cmd_handle_putval */
int cmd_create_putval(char *ret, size_t ret_len, /* {{{ */
status = FORMAT_VL(buffer_ident, sizeof(buffer_ident), vl);
if (status != 0)
- return (status);
+ return status;
escape_string(buffer_ident, sizeof(buffer_ident));
status = format_values(buffer_values, sizeof(buffer_values), ds, vl,
/* store rates = */ 0);
if (status != 0)
- return (status);
+ return status;
escape_string(buffer_values, sizeof(buffer_values));
ssnprintf(ret, ret_len, "PUTVAL %s interval=%.3f %s", buffer_ident,
: CDTIME_T_TO_DOUBLE(plugin_get_interval()),
buffer_values);
- return (0);
+ return 0;
} /* }}} int cmd_create_putval */
diff --git a/src/utils_cmds.c b/src/utils_cmds.c
index 31a9a6fbde3167d9065cb5ed2e1d3c2d2f612232..97702251e18458e1cc5cfd5944bef5b769d8d060 100644 (file)
--- a/src/utils_cmds.c
+++ b/src/utils_cmds.c
fields = malloc((estimate + 1) * sizeof(*fields));
if (fields == NULL) {
cmd_error(CMD_ERROR, err, "malloc failed.");
- return (CMD_ERROR);
+ return CMD_ERROR;
}
#define END_FIELD() \
@@ -130,7 +130,7 @@ static cmd_status_t cmd_split(char *buffer, size_t *ret_len, char ***ret_fields,
if (string[1] == '\0') {
free(fields);
cmd_error(CMD_PARSE_ERROR, err, "Backslash at end of string.");
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
/* un-escape the next character; skip backslash */
@@ -148,7 +148,7 @@ static cmd_status_t cmd_split(char *buffer, size_t *ret_len, char ***ret_fields,
if (in_quotes) {
free(fields);
cmd_error(CMD_PARSE_ERROR, err, "Unterminated quoted string.");
- return (CMD_PARSE_ERROR);
+ return CMD_PARSE_ERROR;
}
#undef NEW_FIELD
@@ -161,7 +161,7 @@ static cmd_status_t cmd_split(char *buffer, size_t *ret_len, char ***ret_fields,
*ret_fields = fields;
else
free(fields);
- return (CMD_OK);
+ return CMD_OK;
} /* int cmd_split */
/*
} else {
ret_cmd->type = CMD_UNKNOWN;
cmd_error(CMD_UNKNOWN_COMMAND, err, "Unknown command `%s'.", command);
- return (CMD_UNKNOWN_COMMAND);
+ return CMD_UNKNOWN_COMMAND;
}
if (status != CMD_OK)
ret_cmd->type = CMD_UNKNOWN;
- return (status);
+ return status;
} /* cmd_status_t cmd_parsev */
cmd_status_t cmd_parse(char *buffer, cmd_t *ret_cmd, const cmd_options_t *opts,
status = cmd_parsev(fields_num, fields, ret_cmd, opts, err);
free(fields);
- return (status);
+ return status;
} /* cmd_status_t cmd_parse */
void cmd_destroy(cmd_t *cmd) {
if (field == NULL) {
errno = EINVAL;
cmd_error(CMD_ERROR, err, "Invalid argument to cmd_parse_option.");
- return (CMD_ERROR);
+ return CMD_ERROR;
}
key = value = field;
value++;
if ((value[0] != '=') || (value == key)) {
/* Whether this is a fatal error is up to the caller. */
- return (CMD_NO_OPTION);
+ return CMD_NO_OPTION;
}
*value = '\0';
value++;
if (ret_value != NULL)
*ret_value = value;
- return (CMD_OK);
+ return CMD_OK;
} /* cmd_status_t cmd_parse_option */
void cmd_error_fh(void *ud, cmd_status_t status, const char *format,
diff --git a/src/utils_cmds_test.c b/src/utils_cmds_test.c
index b540146da3f71f714136db79c4a8fd4e229d9b8e..bb35ce8c86ff07153aff947a64e4a55829a041e5 100644 (file)
--- a/src/utils_cmds_test.c
+++ b/src/utils_cmds_test.c
free(input);
}
- return (test_result);
+ return test_result;
}
int main(int argc, char **argv) {
diff --git a/src/utils_db_query.c b/src/utils_db_query.c
index c8030296a531d16ee873fd4ca6d1d44254b42e14..41f40d9ca67615b48ad54ea5ee1ddf2699878020 100644 (file)
--- a/src/utils_db_query.c
+++ b/src/utils_db_query.c
WARNING("db query utils: The `%s' config option "
"needs exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
string = strdup(ci->values[0].value.string);
if (string == NULL) {
ERROR("db query utils: strdup failed.");
- return (-1);
+ return -1;
}
if (*ret_string != NULL)
free(*ret_string);
*ret_string = string;
- return (0);
+ return 0;
} /* }}} int udb_config_set_string */
static int udb_config_add_string(char ***ret_array, /* {{{ */
WARNING("db query utils: The `%s' config option "
"needs at least one argument.",
ci->key);
- return (-1);
+ return -1;
}
for (int i = 0; i < ci->values_num; i++) {
WARNING("db query utils: Argument %i to the `%s' option "
"is not a string.",
i + 1, ci->key);
- return (-1);
+ return -1;
}
}
array = realloc(*ret_array, sizeof(char *) * (array_len + ci->values_num));
if (array == NULL) {
ERROR("db query utils: realloc failed.");
- return (-1);
+ return -1;
}
*ret_array = array;
if (array[array_len] == NULL) {
ERROR("db query utils: strdup failed.");
*ret_array_len = array_len;
- return (-1);
+ return -1;
}
array_len++;
}
*ret_array_len = array_len;
- return (0);
+ return 0;
} /* }}} int udb_config_add_string */
static int udb_config_set_uint(unsigned int *ret_value, /* {{{ */
WARNING("db query utils: The `%s' config option "
"needs exactly one numeric argument.",
ci->key);
- return (-1);
+ return -1;
}
tmp = ci->values[0].value.number;
if ((tmp < 0.0) || (tmp > ((double)UINT_MAX)))
- return (-ERANGE);
+ return -ERANGE;
*ret_value = (unsigned int)(tmp + .5);
- return (0);
+ return 0;
} /* }}} int udb_config_set_uint */
/*
vl.values = calloc(r->values_num, sizeof(*vl.values));
if (vl.values == NULL) {
ERROR("db query utils: calloc failed.");
- return (-1);
+ return -1;
}
vl.values_len = r_area->ds->ds_num;
value_str, DS_TYPE_TO_STRING(r_area->ds->ds[i].type));
errno = EINVAL;
free(vl.values);
- return (-1);
+ return -1;
}
}
ERROR(
"udb_result_submit: creating type_instance failed with status %d.",
status);
- return (status);
+ return status;
}
} else {
char tmp[DATA_MAX_NAME_LEN];
ERROR(
"udb_result_submit: creating type_instance failed with status %d.",
status);
- return (status);
+ return status;
}
tmp[sizeof(tmp) - 1] = 0;
vl.meta = meta_data_create();
if (vl.meta == NULL) {
ERROR("db query utils:: meta_data_create failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
for (size_t i = 0; i < r->metadata_num; i++) {
ERROR("db query utils:: meta_data_add_string failed.");
meta_data_destroy(vl.meta);
vl.meta = NULL;
- return (status);
+ return status;
}
}
}
vl.meta = NULL;
}
sfree(vl.values);
- return (0);
+ return 0;
} /* }}} void udb_result_submit */
static void udb_result_finish_result(udb_result_t const *r, /* {{{ */
udb_result_preparation_area_t *prep_area,
char **column_names, size_t column_num) {
if ((r == NULL) || (prep_area == NULL))
- return (-EINVAL);
+ return -EINVAL;
#define BAIL_OUT(status) \
prep_area->ds = NULL; \
} /* }}} for (i = 0; i < r->metadata_num; i++) */
#undef BAIL_OUT
- return (0);
+ return 0;
} /* }}} int udb_result_prepare_result */
static void udb_result_free(udb_result_t *r) /* {{{ */
r = calloc(1, sizeof(*r));
if (r == NULL) {
ERROR("db query utils: calloc failed.");
- return (-1);
+ return -1;
}
r->type = NULL;
r->instance_prefix = NULL;
if (status != 0) {
udb_result_free(r);
- return (-1);
+ return -1;
}
/* If all went well, add this result to the list of results. */
last->next = r;
}
- return (0);
+ return 0;
} /* }}} int udb_result_create */
/*
int status;
if ((ret_query_list == NULL) || (ret_query_list_len == NULL))
- return (-EINVAL);
+ return -EINVAL;
query_list = *ret_query_list;
query_list_len = *ret_query_list_len;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("db query utils: The `Query' block "
"needs exactly one string argument.");
- return (-1);
+ return -1;
}
q = calloc(1, sizeof(*q));
if (q == NULL) {
ERROR("db query utils: calloc failed.");
- return (-1);
+ return -1;
}
q->min_version = 0;
q->max_version = UINT_MAX;
status = udb_config_set_string(&q->name, ci);
if (status != 0) {
sfree(q);
- return (status);
+ return status;
}
/* Fill the `udb_query_t' structure.. */
if (status != 0) {
udb_query_free_one(q);
- return (-1);
+ return -1;
}
*ret_query_list = query_list;
*ret_query_list_len = query_list_len;
- return (0);
+ return 0;
} /* }}} int udb_query_create */
void udb_query_free(udb_query_t **query_list, size_t query_list_len) /* {{{ */
(dst_list_len == NULL)) {
ERROR("db query utils: udb_query_pick_from_list_by_name: "
"Invalid argument.");
- return (-EINVAL);
+ return -EINVAL;
}
num_added = 0;
tmp_list = realloc(*dst_list, (tmp_list_len + 1) * sizeof(udb_query_t *));
if (tmp_list == NULL) {
ERROR("db query utils: realloc failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
tmp_list[tmp_list_len] = src_list[i];
ERROR("db query utils: Cannot find query `%s'. Make sure the <Query> "
"block is above the database definition!",
name);
- return (-ENOENT);
+ return -ENOENT;
} else {
DEBUG("db query utils: Added %i versions of query `%s'.", num_added, name);
}
- return (0);
+ return 0;
} /* }}} int udb_query_pick_from_list_by_name */
int udb_query_pick_from_list(oconfig_item_t *ci, /* {{{ */
(dst_list_len == NULL)) {
ERROR("db query utils: udb_query_pick_from_list: "
"Invalid argument.");
- return (-EINVAL);
+ return -EINVAL;
}
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
ERROR("db query utils: The `%s' config option "
"needs exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
name = ci->values[0].value.string;
- return (udb_query_pick_from_list_by_name(name, src_list, src_list_len,
- dst_list, dst_list_len));
+ return udb_query_pick_from_list_by_name(name, src_list, src_list_len,
+ dst_list, dst_list_len);
} /* }}} int udb_query_pick_from_list */
const char *udb_query_get_name(udb_query_t *q) /* {{{ */
{
if (q == NULL)
- return (NULL);
+ return NULL;
- return (q->name);
+ return q->name;
} /* }}} const char *udb_query_get_name */
const char *udb_query_get_statement(udb_query_t *q) /* {{{ */
{
if (q == NULL)
- return (NULL);
+ return NULL;
- return (q->statement);
+ return q->statement;
} /* }}} const char *udb_query_get_statement */
void udb_query_set_user_data(udb_query_t *q, void *user_data) /* {{{ */
void *udb_query_get_user_data(udb_query_t *q) /* {{{ */
{
if (q == NULL)
- return (NULL);
+ return NULL;
- return (q->user_data);
+ return q->user_data;
} /* }}} void *udb_query_get_user_data */
int udb_query_check_version(udb_query_t *q, unsigned int version) /* {{{ */
{
if (q == NULL)
- return (-EINVAL);
+ return -EINVAL;
if ((version < q->min_version) || (version > q->max_version))
- return (0);
+ return 0;
- return (1);
+ return 1;
} /* }}} int udb_query_check_version */
void udb_query_finish_result(udb_query_t const *q, /* {{{ */
int status;
if ((q == NULL) || (prep_area == NULL))
- return (-EINVAL);
+ return -EINVAL;
if ((prep_area->column_num < 1) || (prep_area->host == NULL) ||
(prep_area->plugin == NULL) || (prep_area->db_name == NULL)) {
ERROR("db query utils: Query `%s': Query is not prepared; "
"can't handle result.",
q->name);
- return (-EINVAL);
+ return -EINVAL;
}
#if defined(COLLECT_DEBUG) && COLLECT_DEBUG /* {{{ */
ERROR("db query utils: udb_query_handle_result (%s, %s): "
"All results failed.",
prep_area->db_name, q->name);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int udb_query_handle_result */
int udb_query_prepare_result(udb_query_t const *q, /* {{{ */
int status;
if ((q == NULL) || (prep_area == NULL))
- return (-EINVAL);
+ return -EINVAL;
udb_query_finish_result(q, prep_area);
ERROR("db query utils: Query `%s': Prepare failed: Out of memory.",
q->name);
udb_query_finish_result(q, prep_area);
- return (-ENOMEM);
+ return -ENOMEM;
}
#if defined(COLLECT_DEBUG) && COLLECT_DEBUG
"Column `%s' from `PluginInstanceFrom' could not be found.",
q->plugin_instance_from);
udb_query_finish_result(q, prep_area);
- return (-ENOENT);
+ return -ENOENT;
}
}
/* }}} */
"preparation areas.",
q->name);
udb_query_finish_result(q, prep_area);
- return (-EINVAL);
+ return -EINVAL;
}
status = udb_result_prepare_result(r, r_area, column_names, column_num);
if (status != 0) {
udb_query_finish_result(q, prep_area);
- return (status);
+ return status;
}
}
- return (0);
+ return 0;
} /* }}} int udb_query_prepare_result */
udb_query_preparation_area_t *
next_r_area = &r_area->next;
}
- return (q_area);
+ return q_area;
} /* }}} udb_query_preparation_area_t *udb_query_allocate_preparation_area */
void udb_query_delete_preparation_area(
diff --git a/src/utils_dns.c b/src/utils_dns.c
index 2bda965fffee2dd4ea4d2ffbf9ccc22eab26665c..37fa930ff6c029a7f6d7aac8dbbb8917a53d8ede 100644 (file)
--- a/src/utils_dns.c
+++ b/src/utils_dns.c
break;
if (i >= 16)
- return (0);
+ return 0;
- return (a->s6_addr[i] > b->s6_addr[i] ? 1 : -1);
+ return a->s6_addr[i] > b->s6_addr[i] ? 1 : -1;
} /* int cmp_addrinfo */
static inline int ignore_list_match(const struct in6_addr *addr) {
for (ip_list_t *ptr = IgnoreList; ptr != NULL; ptr = ptr->next)
if (cmp_in6_addr(addr, &ptr->addr) == 0)
- return (1);
- return (0);
+ return 1;
+ return 0;
} /* int ignore_list_match */
static void ignore_list_add(const struct in6_addr *addr) {
uint16_t payload_len;
if (0 > len)
- return (0);
+ return 0;
offset = sizeof(struct ip6_hdr);
nexthdr = ipv6->ip6_nxt;
payload_len = ntohs(ipv6->ip6_plen);
if (ignore_list_match(&c_src_addr))
- return (0);
+ return 0;
/* Parse extension headers. This only handles the standard headers, as
* defined in RFC 2460, correctly. Fragments are discarded. */
/* Catch broken packets */
if ((offset + sizeof(struct ip6_ext)) > (unsigned int)len)
- return (0);
+ return 0;
/* Cannot handle fragments. */
if (IPPROTO_FRAGMENT == nexthdr)
- return (0);
+ return 0;
memcpy(&ext_hdr, (char *)ipv6 + offset, sizeof(struct ip6_ext));
nexthdr = ext_hdr.ip6e_nxt;
/* This header is longer than the packets payload.. WTF? */
if (ext_hdr_len > payload_len)
- return (0);
+ return 0;
offset += ext_hdr_len;
payload_len -= ext_hdr_len;
/* Catch broken and empty packets */
if (((offset + payload_len) > (unsigned int)len) || (payload_len == 0) ||
(payload_len > PCAP_SNAPLEN))
- return (0);
+ return 0;
if (IPPROTO_UDP != nexthdr)
- return (0);
+ return 0;
memcpy(buf, (char *)ipv6 + offset, payload_len);
if (handle_udp((struct udphdr *)buf, payload_len) == 0)
- return (0);
+ return 0;
- return (1); /* Success */
+ return 1; /* Success */
} /* int handle_ipv6 */
/* #endif HAVE_IPV6 */
#else /* if !HAVE_IPV6 */
static int handle_ipv6(__attribute__((unused)) void *pkg,
__attribute__((unused)) int len) {
- return (0);
+ return 0;
}
#endif /* !HAVE_IPV6 */
struct in6_addr c_dst_addr;
if (ip->ip_v == 6)
- return (handle_ipv6((void *)ip, len));
+ return handle_ipv6((void *)ip, len);
in6_addr_from_buffer(&c_src_addr, &ip->ip_src.s_addr,
sizeof(ip->ip_src.s_addr), AF_INET);
in6_addr_from_buffer(&c_dst_addr, &ip->ip_dst.s_addr,
sizeof(ip->ip_dst.s_addr), AF_INET);
if (ignore_list_match(&c_src_addr))
- return (0);
+ return 0;
if (IPPROTO_UDP != ip->ip_p)
return 0;
memcpy(buf, ((char *)ip) + offset, len - offset);
return 0;
memcpy(buf, pkt, len);
if (ETHERTYPE_IPV6 == etype)
- return (handle_ipv6((void *)buf, len));
+ return handle_ipv6((void *)buf, len);
else
return handle_ip((struct ip *)buf, len);
}
uint16_t etype;
if ((0 > len) || ((unsigned int)len < sizeof(struct sll_header)))
- return (0);
+ return 0;
hdr = (struct sll_header *)pkt;
pkt = (u_char *)(hdr + 1);
return 0;
if (ETHERTYPE_IPV6 == etype)
- return (handle_ipv6((void *)pkt, len));
+ return handle_ipv6((void *)pkt, len);
else
return handle_ip((struct ip *)pkt, len);
}
switch (t) {
#if (defined(__NAMESER)) && (__NAMESER >= 19991001)
case ns_t_a:
- return ("A");
+ return "A";
case ns_t_ns:
- return ("NS");
+ return "NS";
case ns_t_md:
- return ("MD");
+ return "MD";
case ns_t_mf:
- return ("MF");
+ return "MF";
case ns_t_cname:
- return ("CNAME");
+ return "CNAME";
case ns_t_soa:
- return ("SOA");
+ return "SOA";
case ns_t_mb:
- return ("MB");
+ return "MB";
case ns_t_mg:
- return ("MG");
+ return "MG";
case ns_t_mr:
- return ("MR");
+ return "MR";
case ns_t_null:
- return ("NULL");
+ return "NULL";
case ns_t_wks:
- return ("WKS");
+ return "WKS";
case ns_t_ptr:
- return ("PTR");
+ return "PTR";
case ns_t_hinfo:
- return ("HINFO");
+ return "HINFO";
case ns_t_minfo:
- return ("MINFO");
+ return "MINFO";
case ns_t_mx:
- return ("MX");
+ return "MX";
case ns_t_txt:
- return ("TXT");
+ return "TXT";
case ns_t_rp:
- return ("RP");
+ return "RP";
case ns_t_afsdb:
- return ("AFSDB");
+ return "AFSDB";
case ns_t_x25:
- return ("X25");
+ return "X25";
case ns_t_isdn:
- return ("ISDN");
+ return "ISDN";
case ns_t_rt:
- return ("RT");
+ return "RT";
case ns_t_nsap:
- return ("NSAP");
+ return "NSAP";
case ns_t_nsap_ptr:
- return ("NSAP-PTR");
+ return "NSAP-PTR";
case ns_t_sig:
- return ("SIG");
+ return "SIG";
case ns_t_key:
- return ("KEY");
+ return "KEY";
case ns_t_px:
- return ("PX");
+ return "PX";
case ns_t_gpos:
- return ("GPOS");
+ return "GPOS";
case ns_t_aaaa:
- return ("AAAA");
+ return "AAAA";
case ns_t_loc:
- return ("LOC");
+ return "LOC";
case ns_t_nxt:
- return ("NXT");
+ return "NXT";
case ns_t_eid:
- return ("EID");
+ return "EID";
case ns_t_nimloc:
- return ("NIMLOC");
+ return "NIMLOC";
case ns_t_srv:
- return ("SRV");
+ return "SRV";
case ns_t_atma:
- return ("ATMA");
+ return "ATMA";
case ns_t_naptr:
- return ("NAPTR");
+ return "NAPTR";
case ns_t_opt:
- return ("OPT");
+ return "OPT";
#if __NAMESER >= 19991006
case ns_t_kx:
- return ("KX");
+ return "KX";
case ns_t_cert:
- return ("CERT");
+ return "CERT";
case ns_t_a6:
- return ("A6");
+ return "A6";
case ns_t_dname:
- return ("DNAME");
+ return "DNAME";
case ns_t_sink:
- return ("SINK");
+ return "SINK";
case ns_t_tsig:
- return ("TSIG");
+ return "TSIG";
#endif
#if __NAMESER >= 20090302
case ns_t_apl:
- return ("APL");
+ return "APL";
case ns_t_ds:
- return ("DS");
+ return "DS";
case ns_t_sshfp:
- return ("SSHFP");
+ return "SSHFP";
case ns_t_ipseckey:
- return ("IPSECKEY");
+ return "IPSECKEY";
case ns_t_rrsig:
- return ("RRSIG");
+ return "RRSIG";
case ns_t_nsec:
- return ("NSEC");
+ return "NSEC";
case ns_t_dnskey:
- return ("DNSKEY");
+ return "DNSKEY";
case ns_t_dhcid:
- return ("DHCID");
+ return "DHCID";
case ns_t_nsec3:
- return ("NSEC3");
+ return "NSEC3";
case ns_t_nsec3param:
- return ("NSEC3PARAM");
+ return "NSEC3PARAM";
case ns_t_hip:
- return ("HIP");
+ return "HIP";
case ns_t_spf:
- return ("SPF");
+ return "SPF";
case ns_t_ixfr:
- return ("IXFR");
+ return "IXFR";
#endif
case ns_t_axfr:
- return ("AXFR");
+ return "AXFR";
case ns_t_mailb:
- return ("MAILB");
+ return "MAILB";
case ns_t_maila:
- return ("MAILA");
+ return "MAILA";
case ns_t_any:
- return ("ANY");
+ return "ANY";
#if __NAMESER >= 19991006
case ns_t_zxfr:
- return ("ZXFR");
+ return "ZXFR";
#endif
#if __NAMESER >= 20090302
case ns_t_dlv:
- return ("DLV");
+ return "DLV";
#endif
/* #endif __NAMESER >= 19991001 */
#elif (defined(__BIND)) && (__BIND >= 19950621)
case T_A:
- return ("A"); /* 1 ... */
+ return "A"; /* 1 ... */
case T_NS:
- return ("NS");
+ return "NS";
case T_MD:
- return ("MD");
+ return "MD";
case T_MF:
- return ("MF");
+ return "MF";
case T_CNAME:
- return ("CNAME");
+ return "CNAME";
case T_SOA:
- return ("SOA");
+ return "SOA";
case T_MB:
- return ("MB");
+ return "MB";
case T_MG:
- return ("MG");
+ return "MG";
case T_MR:
- return ("MR");
+ return "MR";
case T_NULL:
- return ("NULL");
+ return "NULL";
case T_WKS:
- return ("WKS");
+ return "WKS";
case T_PTR:
- return ("PTR");
+ return "PTR";
case T_HINFO:
- return ("HINFO");
+ return "HINFO";
case T_MINFO:
- return ("MINFO");
+ return "MINFO";
case T_MX:
- return ("MX");
+ return "MX";
case T_TXT:
- return ("TXT");
+ return "TXT";
case T_RP:
- return ("RP");
+ return "RP";
case T_AFSDB:
- return ("AFSDB");
+ return "AFSDB";
case T_X25:
- return ("X25");
+ return "X25";
case T_ISDN:
- return ("ISDN");
+ return "ISDN";
case T_RT:
- return ("RT");
+ return "RT";
case T_NSAP:
- return ("NSAP");
+ return "NSAP";
case T_NSAP_PTR:
- return ("NSAP_PTR");
+ return "NSAP_PTR";
case T_SIG:
- return ("SIG");
+ return "SIG";
case T_KEY:
- return ("KEY");
+ return "KEY";
case T_PX:
- return ("PX");
+ return "PX";
case T_GPOS:
- return ("GPOS");
+ return "GPOS";
case T_AAAA:
- return ("AAAA");
+ return "AAAA";
case T_LOC:
- return ("LOC");
+ return "LOC";
case T_NXT:
- return ("NXT");
+ return "NXT";
case T_EID:
- return ("EID");
+ return "EID";
case T_NIMLOC:
- return ("NIMLOC");
+ return "NIMLOC";
case T_SRV:
- return ("SRV");
+ return "SRV";
case T_ATMA:
- return ("ATMA");
+ return "ATMA";
case T_NAPTR:
- return ("NAPTR"); /* ... 35 */
+ return "NAPTR"; /* ... 35 */
#if (__BIND >= 19960801)
case T_KX:
- return ("KX"); /* 36 ... */
+ return "KX"; /* 36 ... */
case T_CERT:
- return ("CERT");
+ return "CERT";
case T_A6:
- return ("A6");
+ return "A6";
case T_DNAME:
- return ("DNAME");
+ return "DNAME";
case T_SINK:
- return ("SINK");
+ return "SINK";
case T_OPT:
- return ("OPT");
+ return "OPT";
case T_APL:
- return ("APL");
+ return "APL";
case T_DS:
- return ("DS");
+ return "DS";
case T_SSHFP:
- return ("SSHFP");
+ return "SSHFP";
case T_RRSIG:
- return ("RRSIG");
+ return "RRSIG";
case T_NSEC:
- return ("NSEC");
+ return "NSEC";
case T_DNSKEY:
- return ("DNSKEY"); /* ... 48 */
+ return "DNSKEY"; /* ... 48 */
case T_TKEY:
- return ("TKEY"); /* 249 */
+ return "TKEY"; /* 249 */
#endif /* __BIND >= 19960801 */
case T_TSIG:
- return ("TSIG"); /* 250 ... */
+ return "TSIG"; /* 250 ... */
case T_IXFR:
- return ("IXFR");
+ return "IXFR";
case T_AXFR:
- return ("AXFR");
+ return "AXFR";
case T_MAILB:
- return ("MAILB");
+ return "MAILB";
case T_MAILA:
- return ("MAILA");
+ return "MAILA";
case T_ANY:
- return ("ANY"); /* ... 255 */
+ return "ANY"; /* ... 255 */
#endif /* __BIND >= 19950621 */
default:
ssnprintf(buf, sizeof(buf), "#%i", t);
- return (buf);
+ return buf;
} /* switch (t) */
}
switch (rcode) {
#if (defined(__NAMESER)) && (__NAMESER >= 19991006)
case ns_r_noerror:
- return ("NOERROR");
+ return "NOERROR";
case ns_r_formerr:
- return ("FORMERR");
+ return "FORMERR";
case ns_r_servfail:
- return ("SERVFAIL");
+ return "SERVFAIL";
case ns_r_nxdomain:
- return ("NXDOMAIN");
+ return "NXDOMAIN";
case ns_r_notimpl:
- return ("NOTIMPL");
+ return "NOTIMPL";
case ns_r_refused:
- return ("REFUSED");
+ return "REFUSED";
case ns_r_yxdomain:
- return ("YXDOMAIN");
+ return "YXDOMAIN";
case ns_r_yxrrset:
- return ("YXRRSET");
+ return "YXRRSET";
case ns_r_nxrrset:
- return ("NXRRSET");
+ return "NXRRSET";
case ns_r_notauth:
- return ("NOTAUTH");
+ return "NOTAUTH";
case ns_r_notzone:
- return ("NOTZONE");
+ return "NOTZONE";
case ns_r_max:
- return ("MAX");
+ return "MAX";
case ns_r_badsig:
- return ("BADSIG");
+ return "BADSIG";
case ns_r_badkey:
- return ("BADKEY");
+ return "BADKEY";
case ns_r_badtime:
- return ("BADTIME");
+ return "BADTIME";
/* #endif __NAMESER >= 19991006 */
#elif (defined(__BIND)) && (__BIND >= 19950621)
case NOERROR:
- return ("NOERROR");
+ return "NOERROR";
case FORMERR:
- return ("FORMERR");
+ return "FORMERR";
case SERVFAIL:
- return ("SERVFAIL");
+ return "SERVFAIL";
case NXDOMAIN:
- return ("NXDOMAIN");
+ return "NXDOMAIN";
case NOTIMP:
- return ("NOTIMP");
+ return "NOTIMP";
case REFUSED:
- return ("REFUSED");
+ return "REFUSED";
#if defined(YXDOMAIN) && defined(NXRRSET)
case YXDOMAIN:
- return ("YXDOMAIN");
+ return "YXDOMAIN";
case YXRRSET:
- return ("YXRRSET");
+ return "YXRRSET";
case NXRRSET:
- return ("NXRRSET");
+ return "NXRRSET";
case NOTAUTH:
- return ("NOTAUTH");
+ return "NOTAUTH";
case NOTZONE:
- return ("NOTZONE");
+ return "NOTZONE";
#endif /* RFC2136 rcodes */
#endif /* __BIND >= 19950621 */
default:
ssnprintf(buf, sizeof(buf), "RCode%i", rcode);
- return (buf);
+ return buf;
}
} /* const char *rcode_str (int rcode) */
diff --git a/src/utils_dpdk.c b/src/utils_dpdk.c
index e3c737931a01f2f3c2a3084efb5eb8c222cc9d11..3a30438d5c170eff371a9cd787883fd741c131da 100644 (file)
--- a/src/utils_dpdk.c
+++ b/src/utils_dpdk.c
return -EINVAL;
}
- return (phc->shm_size - sizeof(dpdk_helper_ctx_t));
+ return phc->shm_size - sizeof(dpdk_helper_ctx_t);
}
int dpdk_helper_init(const char *name, size_t data_size,
diff --git a/src/utils_fbhash.c b/src/utils_fbhash.c
index f94e2e5b7a08a3e6b437a797b78876e1e53f1292..366b44b8e57e5de40ade73894d4abe848f8d3918 100644 (file)
--- a/src/utils_fbhash.c
+++ b/src/utils_fbhash.c
fh = fopen(h->filename, "r");
if (fh == NULL)
- return (-1);
+ return -1;
fl.l_type = F_RDLCK;
fl.l_whence = SEEK_SET;
status = fcntl(fileno(fh), F_SETLK, &fl);
if (status != 0) {
fclose(fh);
- return (-1);
+ return -1;
}
tree = c_avl_create((int (*)(const void *, const void *))strcmp);
if (tree == NULL) {
fclose(fh);
- return (-1);
+ return -1;
}
/* Read `fh' into `tree' */
fbh_free_tree(h->tree);
h->tree = tree;
- return (0);
+ return 0;
} /* }}} int fbh_read_file */
static int fbh_check_file(fbhash_t *h) /* {{{ */
status = stat(h->filename, &statbuf);
if (status != 0)
- return (-1);
+ return -1;
if (h->mtime >= statbuf.st_mtime)
- return (0);
+ return 0;
status = fbh_read_file(h);
if (status == 0)
h->mtime = statbuf.st_mtime;
- return (status);
+ return status;
} /* }}} int fbh_check_file */
/*
int status;
if (file == NULL)
- return (NULL);
+ return NULL;
h = calloc(1, sizeof(*h));
if (h == NULL)
- return (NULL);
+ return NULL;
h->filename = strdup(file);
if (h->filename == NULL) {
free(h);
- return (NULL);
+ return NULL;
}
h->mtime = 0;
if (status != 0) {
fbh_destroy(h);
free(h);
- return (NULL);
+ return NULL;
}
- return (h);
+ return h;
} /* }}} fbhash_t *fbh_create */
void fbh_destroy(fbhash_t *h) /* {{{ */
int status;
if ((h == NULL) || (key == NULL))
- return (NULL);
+ return NULL;
value = NULL;
value_copy = NULL;
pthread_mutex_unlock(&h->lock);
- return (value_copy);
+ return value_copy;
} /* }}} char *fbh_get */
index 0436340dfdd2f13ad5f142e270f860d3f4ea9494..fd6c4e2f32548a1117fb2f93bcd1ad58cdc22efb 100644 (file)
do { \
status = ssnprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
if (status < 1) { \
- return (-1); \
+ return -1; \
} else if (((size_t)status) >= (ret_len - offset)) { \
- return (-1); \
+ return -1; \
} else \
offset += ((size_t)status); \
} while (0)
else {
ERROR("gr_format_values plugin: Unknown data source type: %i",
ds->ds[ds_num].type);
- return (-1);
+ return -1;
}
#undef BUFFER_ADD
- return (0);
+ return 0;
}
static void gr_copy_escape_part(char *dst, const char *src, size_t dst_len,
ssnprintf(ret, ret_len, "%s%s%s.%s.%s", prefix, n_host, postfix, tmp_plugin,
tmp_type);
- return (0);
+ return 0;
}
static void escape_graphite_string(char *buffer, char escape_char) {
if (status != 0) {
ERROR("format_graphite: error with gr_format_name");
sfree(rates);
- return (status);
+ return status;
}
escape_graphite_string(key, escape_char);
if (status != 0) {
ERROR("format_graphite: error with gr_format_values");
sfree(rates);
- return (status);
+ return status;
}
/* Compute the graphite command */
"Need %zu bytes.",
message_len + 1);
sfree(rates);
- return (-ENOMEM);
+ return -ENOMEM;
}
/* Append it in case we got multiple data set */
if ((buffer_pos + message_len) >= buffer_size) {
ERROR("format_graphite: target buffer too small");
sfree(rates);
- return (-ENOMEM);
+ return -ENOMEM;
}
memcpy((void *)(buffer + buffer_pos), message, message_len);
buffer_pos += message_len;
buffer[buffer_pos] = '\0';
}
sfree(rates);
- return (status);
+ return status;
} /* int format_graphite */
index 1a0e151de27491cf918228e62490233d46a7fe48..67aebbaf8e0cb103890a6ce3b8b9d04f10b73c1d 100644 (file)
--- a/src/utils_format_json.c
+++ b/src/utils_format_json.c
size_t dst_pos;
if ((buffer == NULL) || (string == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (buffer_size < 3)
- return (-ENOMEM);
+ return -ENOMEM;
dst_pos = 0;
do { \
if (dst_pos >= (buffer_size - 1)) { \
buffer[buffer_size - 1] = 0; \
- return (-ENOMEM); \
+ return -ENOMEM; \
} \
buffer[dst_pos] = (c); \
dst_pos++; \
#undef BUFFER_ADD
- return (0);
+ return 0;
} /* }}} int json_escape_string */
static int values_to_json(char *buffer, size_t buffer_size, /* {{{ */
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
- return (-1); \
+ return -1; \
} else if (((size_t)status) >= (buffer_size - offset)) { \
sfree(rates); \
- return (-ENOMEM); \
+ return -ENOMEM; \
} else \
offset += ((size_t)status); \
} while (0)
if (rates == NULL) {
WARNING("utils_format_json: uc_get_rate failed.");
sfree(rates);
- return (-1);
+ return -1;
}
if (isfinite(rates[i]))
else {
ERROR("format_json: Unknown data source type: %i", ds->ds[i].type);
sfree(rates);
- return (-1);
+ return -1;
}
} /* for ds->ds_num */
BUFFER_ADD("]");
DEBUG("format_json: values_to_json: buffer = %s;", buffer);
sfree(rates);
- return (0);
+ return 0;
} /* }}} int values_to_json */
static int dstypes_to_json(char *buffer, size_t buffer_size, /* {{{ */
int status; \
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
- return (-1); \
+ return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
- return (-ENOMEM); \
+ return -ENOMEM; \
else \
offset += ((size_t)status); \
} while (0)
DEBUG("format_json: dstypes_to_json: buffer = %s;", buffer);
- return (0);
+ return 0;
} /* }}} int dstypes_to_json */
static int dsnames_to_json(char *buffer, size_t buffer_size, /* {{{ */
int status; \
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
- return (-1); \
+ return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
- return (-ENOMEM); \
+ return -ENOMEM; \
else \
offset += ((size_t)status); \
} while (0)
DEBUG("format_json: dsnames_to_json: buffer = %s;", buffer);
- return (0);
+ return 0;
} /* }}} int dsnames_to_json */
static int meta_data_keys_to_json(char *buffer, size_t buffer_size, /* {{{ */
do { \
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
- return (-1); \
+ return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
- return (-ENOMEM); \
+ return -ENOMEM; \
else \
offset += ((size_t)status); \
} while (0)
} /* for (keys) */
if (offset == 0)
- return (ENOENT);
+ return ENOENT;
buffer[0] = '{'; /* replace leading ',' */
BUFFER_ADD("}");
#undef BUFFER_ADD
- return (0);
+ return 0;
} /* }}} int meta_data_keys_to_json */
static int meta_data_to_json(char *buffer, size_t buffer_size, /* {{{ */
int status;
if ((buffer == NULL) || (buffer_size == 0) || (meta == NULL))
- return (EINVAL);
+ return EINVAL;
status = meta_data_toc(meta, &keys);
if (status <= 0)
- return (status);
+ return status;
keys_num = (size_t)status;
status = meta_data_keys_to_json(buffer, buffer_size, meta, keys, keys_num);
do { \
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
- return (-1); \
+ return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
- return (-ENOMEM); \
+ return -ENOMEM; \
else \
offset += ((size_t)status); \
} while (0)
status = values_to_json(temp, sizeof(temp), ds, vl, store_rates);
if (status != 0)
- return (status);
+ return status;
BUFFER_ADD("\"values\":%s", temp);
status = dstypes_to_json(temp, sizeof(temp), ds);
if (status != 0)
- return (status);
+ return status;
BUFFER_ADD(",\"dstypes\":%s", temp);
status = dsnames_to_json(temp, sizeof(temp), ds);
if (status != 0)
- return (status);
+ return status;
BUFFER_ADD(",\"dsnames\":%s", temp);
BUFFER_ADD(",\"time\":%.3f", CDTIME_T_TO_DOUBLE(vl->time));
do { \
status = json_escape_string(temp, sizeof(temp), (value)); \
if (status != 0) \
- return (status); \
+ return status; \
BUFFER_ADD(",\"%s\":%s", (key), temp); \
} while (0)
memset(meta_buffer, 0, sizeof(meta_buffer));
status = meta_data_to_json(meta_buffer, sizeof(meta_buffer), vl->meta);
if (status != 0)
- return (status);
+ return status;
BUFFER_ADD(",\"meta\":%s", meta_buffer);
} /* if (vl->meta != NULL) */
DEBUG("format_json: value_list_to_json: buffer = %s;", buffer);
- return (0);
+ return 0;
} /* }}} int value_list_to_json */
static int format_json_value_list_nocheck(char *buffer, /* {{{ */
status = value_list_to_json(temp, sizeof(temp), ds, vl, store_rates);
if (status != 0)
- return (status);
+ return status;
temp_size = strlen(temp);
memcpy(buffer + (*ret_buffer_fill), temp, temp_size + 1);
(*ret_buffer_fill) += temp_size;
(*ret_buffer_free) -= temp_size;
- return (0);
+ return 0;
} /* }}} int format_json_value_list_nocheck */
int format_json_initialize(char *buffer, /* {{{ */
if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
(ret_buffer_free == NULL))
- return (-EINVAL);
+ return -EINVAL;
buffer_fill = *ret_buffer_fill;
buffer_free = *ret_buffer_free;
buffer_fill = 0;
if (buffer_free < 3)
- return (-ENOMEM);
+ return -ENOMEM;
memset(buffer, 0, buffer_free);
*ret_buffer_fill = buffer_fill;
*ret_buffer_free = buffer_free;
- return (0);
+ return 0;
} /* }}} int format_json_initialize */
int format_json_finalize(char *buffer, /* {{{ */
if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
(ret_buffer_free == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (*ret_buffer_free < 2)
- return (-ENOMEM);
+ return -ENOMEM;
/* Replace the leading comma added in `value_list_to_json' with a square
* bracket. */
if (buffer[0] != ',')
- return (-EINVAL);
+ return -EINVAL;
buffer[0] = '[';
pos = *ret_buffer_fill;
(*ret_buffer_fill)++;
(*ret_buffer_free)--;
- return (0);
+ return 0;
} /* }}} int format_json_finalize */
int format_json_value_list(char *buffer, /* {{{ */
int store_rates) {
if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
(ret_buffer_free == NULL) || (ds == NULL) || (vl == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (*ret_buffer_free < 3)
- return (-ENOMEM);
+ return -ENOMEM;
- return (format_json_value_list_nocheck(buffer, ret_buffer_fill,
- ret_buffer_free, ds, vl, store_rates,
- (*ret_buffer_free) - 2));
+ return format_json_value_list_nocheck(buffer, ret_buffer_fill,
+ ret_buffer_free, ds, vl, store_rates,
+ (*ret_buffer_free) - 2);
} /* }}} int format_json_value_list */
#if HAVE_LIBYAJL
if (str == NULL)
return (int)yajl_gen_null(g);
- return (int)yajl_gen_string(g, (unsigned char const *)str,
+ return (int)yajl_gen_string(g, (const unsigned char *)str,
(unsigned int)strlen(str));
} /* }}} int json_add_string */
index 224e8a52e96e7c4144057b127e369bd5974acacd..4378d7ffe0793bec2577f251653576a67ace1c16 100644 (file)
size_t dst_pos;
if ((buffer == NULL) || (string == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (buffer_size < 3)
- return (-ENOMEM);
+ return -ENOMEM;
dst_pos = 0;
do { \
if (dst_pos >= (buffer_size - 1)) { \
buffer[buffer_size - 1] = 0; \
- return (-ENOMEM); \
+ return -ENOMEM; \
} \
buffer[dst_pos] = (c); \
dst_pos++; \
#undef BUFFER_ADD
- return (0);
+ return 0;
} /* }}} int kairosdb_escape_string */
static int values_to_kairosdb(char *buffer, size_t buffer_size, /* {{{ */
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
- return (-1); \
+ return -1; \
} else if (((size_t)status) >= (buffer_size - offset)) { \
sfree(rates); \
- return (-ENOMEM); \
+ return -ENOMEM; \
} else \
offset += ((size_t)status); \
} while (0)
"%s|%s|%s|%s|%s",
vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
ds->ds[ds_idx].name);
- return (-1);
+ return -1;
}
} else if (store_rates) {
if (rates == NULL)
vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
ds->ds[ds_idx].name);
- return (-1);
+ return -1;
}
if (isfinite(rates[ds_idx])) {
vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
ds->ds[ds_idx].name);
sfree(rates);
- return (-1);
+ return -1;
}
} else if (ds->ds[ds_idx].type == DS_TYPE_COUNTER) {
BUFFER_ADD("[[");
} else {
ERROR("format_kairosdb: Unknown data source type: %i", ds->ds[ds_idx].type);
sfree(rates);
- return (-1);
+ return -1;
}
BUFFER_ADD("]]");
DEBUG("format_kairosdb: values_to_kairosdb: buffer = %s;", buffer);
sfree(rates);
- return (0);
+ return 0;
} /* }}} int values_to_kairosdb */
static int value_list_to_kairosdb(char *buffer, size_t buffer_size, /* {{{ */
do { \
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
- return (-1); \
+ return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
- return (-ENOMEM); \
+ return -ENOMEM; \
else \
offset += ((size_t)status); \
} while (0)
do { \
status = kairosdb_escape_string(temp, sizeof(temp), (value)); \
if (status != 0) \
- return (status); \
+ return status; \
BUFFER_ADD(",\"%s\": %s", (key), temp); \
} while (0)
status = values_to_kairosdb(temp, sizeof(temp), ds, vl, store_rates, i);
if (status != 0)
- return (status);
+ return status;
BUFFER_ADD("\", \"datapoints\": %s", temp);
DEBUG("format_kairosdb: value_list_to_kairosdb: buffer = %s;", buffer);
- return (0);
+ return 0;
} /* }}} int value_list_to_kairosdb */
static int format_kairosdb_value_list_nocheck(
status = value_list_to_kairosdb(temp, sizeof(temp), ds, vl, store_rates,
http_attrs, http_attrs_num, data_ttl);
if (status != 0)
- return (status);
+ return status;
temp_size = strlen(temp);
memcpy(buffer + (*ret_buffer_fill), temp, temp_size + 1);
(*ret_buffer_fill) += temp_size;
(*ret_buffer_free) -= temp_size;
- return (0);
+ return 0;
} /* }}} int format_kairosdb_value_list_nocheck */
int format_kairosdb_initialize(char *buffer, /* {{{ */
if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
(ret_buffer_free == NULL))
- return (-EINVAL);
+ return -EINVAL;
buffer_fill = *ret_buffer_fill;
buffer_free = *ret_buffer_free;
buffer_fill = 0;
if (buffer_free < 3)
- return (-ENOMEM);
+ return -ENOMEM;
memset(buffer, 0, buffer_free);
*ret_buffer_fill = buffer_fill;
*ret_buffer_free = buffer_free;
- return (0);
+ return 0;
} /* }}} int format_kairosdb_initialize */
int format_kairosdb_finalize(char *buffer, /* {{{ */
if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
(ret_buffer_free == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (*ret_buffer_free < 2)
- return (-ENOMEM);
+ return -ENOMEM;
/* Replace the leading comma added in `value_list_to_kairosdb' with a square
* bracket. */
if (buffer[0] != ',')
- return (-EINVAL);
+ return -EINVAL;
buffer[0] = '[';
pos = *ret_buffer_fill;
(*ret_buffer_fill)++;
(*ret_buffer_free)--;
- return (0);
+ return 0;
} /* }}} int format_kairosdb_finalize */
int format_kairosdb_value_list(char *buffer, /* {{{ */
size_t http_attrs_num, int data_ttl) {
if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
(ret_buffer_free == NULL) || (ds == NULL) || (vl == NULL))
- return (-EINVAL);
+ return -EINVAL;
if (*ret_buffer_free < 3)
- return (-ENOMEM);
-
- return (format_kairosdb_value_list_nocheck(
- buffer, ret_buffer_fill, ret_buffer_free, ds, vl, store_rates,
- (*ret_buffer_free) - 2, http_attrs, http_attrs_num, data_ttl));
+ return -ENOMEM;
+
+ return format_kairosdb_value_list_nocheck(buffer, ret_buffer_fill,
+ ret_buffer_free, ds, vl,
+ store_rates,
+ (*ret_buffer_free) - 2,
+ http_attrs, http_attrs_num,
+ data_ttl);
} /* }}} int format_kairosdb_value_list */
/* vim: set sw=2 sts=2 et fdm=marker : */
diff --git a/src/utils_ignorelist.c b/src/utils_ignorelist.c
index 9cf6aa1ed1e065e66e9dea13ee2596c427ab2636..29b2af217f4f3a3c662d85cd16671e0f2ab20077 100644 (file)
--- a/src/utils_ignorelist.c
+++ b/src/utils_ignorelist.c
re = calloc(1, sizeof(*re));
if (re == NULL) {
ERROR("ignorelist_append_regex: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
status = regcomp(re, re_str, REG_EXTENDED);
"failed: %s",
re_str, errbuf);
sfree(re);
- return (status);
+ return status;
}
entry = calloc(1, sizeof(*entry));
ERROR("ignorelist_append_regex: calloc failed.");
regfree(re);
sfree(re);
- return (ENOMEM);
+ return ENOMEM;
}
entry->rmatch = re;
ignorelist_append(il, entry);
- return (0);
+ return 0;
} /* int ignorelist_append_regex */
#endif
/* create new entry */
if ((new = calloc(1, sizeof(*new))) == NULL) {
ERROR("cannot allocate new entry");
- return (1);
+ return 1;
}
new->smatch = sstrdup(entry);
/* append new entry */
ignorelist_append(il, new);
- return (0);
+ return 0;
} /* int ignorelist_append_string(ignorelist_t *il, const char *entry) */
#if HAVE_REGEX_H
/* match regex */
if (regexec(item->rmatch, entry, 0, NULL, 0) == 0)
- return (1);
+ return 1;
- return (0);
+ return 0;
} /* int ignorelist_match_regex (ignorelist_item_t *item, const char *entry) */
#endif
@@ -165,9 +165,9 @@ static int ignorelist_match_string(ignorelist_item_t *item, const char *entry) {
(strlen(entry) > 0));
if (strcmp(entry, item->smatch) == 0)
- return (1);
+ return 1;
- return (0);
+ return 0;
} /* int ignorelist_match_string (ignorelist_item_t *item, const char *entry) */
/* *** *** *** ******************************************** *** *** *** */
*/
il->ignore = invert ? 0 : 1;
- return (il);
+ return il;
} /* ignorelist_t *ignorelist_create (int ignore) */
/*
if (il == NULL) {
DEBUG("add called with ignorelist_t == NULL");
- return (1);
+ return 1;
}
len = strlen(entry);
/* append nothing */
if (len == 0) {
DEBUG("not appending: empty entry");
- return (1);
+ return 1;
}
#if HAVE_REGEX_H
int ignorelist_match(ignorelist_t *il, const char *entry) {
/* if no entries, collect all */
if ((il == NULL) || (il->head == NULL))
- return (0);
+ return 0;
if ((entry == NULL) || (strlen(entry) == 0))
- return (0);
+ return 0;
/* traverse list and check entries */
for (ignorelist_item_t *traverse = il->head; traverse != NULL;
#if HAVE_REGEX_H
if (traverse->rmatch != NULL) {
if (ignorelist_match_regex(traverse, entry))
- return (il->ignore);
+ return il->ignore;
} else
#endif
{
if (ignorelist_match_string(traverse, entry))
- return (il->ignore);
+ return il->ignore;
}
} /* for traverse */
- return (1 - il->ignore);
+ return 1 - il->ignore;
} /* int ignorelist_match (ignorelist_t *il, const char *entry) */
diff --git a/src/utils_latency.c b/src/utils_latency.c
index f30b265b6c5d9233b3d5c2c6ca7dda7775d53729..625fc42e82bc35bffc05ba925d5f25b59dbc81dd 100644 (file)
--- a/src/utils_latency.c
+++ b/src/utils_latency.c
lc = calloc(1, sizeof(*lc));
if (lc == NULL)
- return (NULL);
+ return NULL;
lc->bin_width = HISTOGRAM_DEFAULT_BIN_WIDTH;
latency_counter_reset(lc);
- return (lc);
+ return lc;
} /* }}} latency_counter_t *latency_counter_create */
void latency_counter_destroy(latency_counter_t *lc) /* {{{ */
cdtime_t latency_counter_get_min(latency_counter_t *lc) /* {{{ */
{
if (lc == NULL)
- return (0);
- return (lc->min);
+ return 0;
+ return lc->min;
} /* }}} cdtime_t latency_counter_get_min */
cdtime_t latency_counter_get_max(latency_counter_t *lc) /* {{{ */
{
if (lc == NULL)
- return (0);
- return (lc->max);
+ return 0;
+ return lc->max;
} /* }}} cdtime_t latency_counter_get_max */
cdtime_t latency_counter_get_sum(latency_counter_t *lc) /* {{{ */
{
if (lc == NULL)
- return (0);
- return (lc->sum);
+ return 0;
+ return lc->sum;
} /* }}} cdtime_t latency_counter_get_sum */
size_t latency_counter_get_num(latency_counter_t *lc) /* {{{ */
{
if (lc == NULL)
- return (0);
- return (lc->num);
+ return 0;
+ return lc->num;
} /* }}} size_t latency_counter_get_num */
cdtime_t latency_counter_get_average(latency_counter_t *lc) /* {{{ */
double average;
if ((lc == NULL) || (lc->num == 0))
- return (0);
+ return 0;
average = CDTIME_T_TO_DOUBLE(lc->sum) / ((double)lc->num);
- return (DOUBLE_TO_CDTIME_T(average));
+ return DOUBLE_TO_CDTIME_T(average);
} /* }}} cdtime_t latency_counter_get_average */
cdtime_t latency_counter_get_percentile(latency_counter_t *lc, /* {{{ */
size_t i;
if ((lc == NULL) || (lc->num == 0) || !((percent > 0.0) && (percent < 100.0)))
- return (0);
+ return 0;
/* Find index i so that at least "percent" events are within i+1 ms. */
percent_upper = 0.0;
}
if (i >= HISTOGRAM_NUM_BINS)
- return (0);
+ return 0;
assert(percent_upper >= percent);
assert(percent_lower < percent);
if (i == 0)
- return (lc->bin_width);
+ return lc->bin_width;
latency_lower = ((cdtime_t)i) * lc->bin_width;
p = (percent - percent_lower) / (percent_upper - percent_lower);
DEBUG("latency_counter_get_percentile: latency_interpolated = %.3f",
CDTIME_T_TO_DOUBLE(latency_interpolated));
- return (latency_interpolated);
+ return latency_interpolated;
} /* }}} cdtime_t latency_counter_get_percentile */
double latency_counter_get_rate(const latency_counter_t *lc, /* {{{ */
cdtime_t lower, cdtime_t upper,
const cdtime_t now) {
if ((lc == NULL) || (lc->num == 0))
- return (NAN);
+ return NAN;
if (upper && (upper < lower))
- return (NAN);
+ return NAN;
if (lower == upper)
- return (0);
+ return 0;
/* Buckets have an exclusive lower bound and an inclusive upper bound. That
* means that the first bucket, index 0, represents (0-bin_width]. That means
/* lower is greater than the longest latency observed => rate is zero. */
if (lower_bin >= HISTOGRAM_NUM_BINS)
- return (0);
+ return 0;
cdtime_t upper_bin = HISTOGRAM_NUM_BINS - 1;
if (upper)
index 674e2752039cf9163e36a15ef3bf43b5fab0ed04..d0832cbcfd93e0f8e19a495bb35f17d68ffa6a37 100644 (file)
DOUBLE_TO_CDTIME_T(ci->values[1].value.number);
conf->buckets_num++;
- return (0);
+ return 0;
} /* int latency_config_add_bucket */
int latency_config(latency_config_t *conf, oconfig_item_t *ci,
diff --git a/src/utils_lua.c b/src/utils_lua.c
index 7710121695585b083f2d91f227892791d45b943c..4e570ff3c7c703d510361cc84b1c7283b7e7b250 100644 (file)
--- a/src/utils_lua.c
+++ b/src/utils_lua.c
const data_set_t *ds, value_t *ret_values) {
if (!lua_istable(L, -1)) {
WARNING("ltoc_values: not a table");
- return (-1);
+ return -1;
}
/* Push initial key */
WARNING("ltoc_values: invalid size for datasource \"%s\": expected %zu, "
"got %zu",
ds->type, ds->ds_num, i);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int ltoc_values */
static int ltoc_table_values(lua_State *L, int idx, /* {{{ */
"value, not a table.",
lua_typename(L, lua_type(L, -1)));
lua_pop(L, 1);
- return (-1);
+ return -1;
}
vl->values_len = ds->ds_num;
ERROR("utils_lua: calloc failed.");
vl->values_len = 0;
lua_pop(L, 1);
- return (-1);
+ return -1;
}
int status = ltoc_values(L, ds, vl->values);
sfree(vl->values);
}
- return (status);
+ return status;
} /* }}} int ltoc_table_values */
static int luaC_pushvalues(lua_State *L, const data_set_t *ds,
lua_settable(L, -3);
}
- return (0);
+ return 0;
} /* }}} int luaC_pushvalues */
static int luaC_pushdstypes(lua_State *L, const data_set_t *ds) /* {{{ */
lua_settable(L, -3);
}
- return (0);
+ return 0;
} /* }}} int luaC_pushdstypes */
static int luaC_pushdsnames(lua_State *L, const data_set_t *ds) /* {{{ */
lua_settable(L, -3);
}
- return (0);
+ return 0;
} /* }}} int luaC_pushdsnames */
/*
cdtime_t luaC_tocdtime(lua_State *L, int idx) /* {{{ */
{
if (!lua_isnumber(L, /* stack pos = */ idx))
- return (0);
+ return 0;
double d = lua_tonumber(L, idx);
- return (DOUBLE_TO_CDTIME_T(d));
+ return DOUBLE_TO_CDTIME_T(d);
} /* }}} int ltoc_table_cdtime */
int luaC_tostringbuffer(lua_State *L, int idx, /* {{{ */
char *buffer, size_t buffer_size) {
const char *str = lua_tostring(L, idx);
if (str == NULL)
- return (-1);
+ return -1;
sstrncpy(buffer, str, buffer_size);
- return (0);
+ return 0;
} /* }}} int luaC_tostringbuffer */
value_t luaC_tovalue(lua_State *L, int idx, int ds_type) /* {{{ */
value_t v = {0};
if (!lua_isnumber(L, idx))
- return (v);
+ return v;
if (ds_type == DS_TYPE_GAUGE)
v.gauge = (gauge_t)lua_tonumber(L, /* stack pos = */ -1);
else if (ds_type == DS_TYPE_ABSOLUTE)
v.absolute = (absolute_t)lua_tointeger(L, /* stack pos = */ -1);
- return (v);
+ return v;
} /* }}} value_t luaC_tovalue */
value_list_t *luaC_tovaluelist(lua_State *L, int idx) /* {{{ */
/* Check that idx is in the valid range */
if ((idx < 1) || (idx > lua_gettop(L))) {
DEBUG("luaC_tovaluelist: idx(%d), top(%d)", idx, stack_top_before);
- return (NULL);
+ return NULL;
}
value_list_t *vl = calloc(1, sizeof(*vl));
if (vl == NULL) {
DEBUG("luaC_tovaluelist: calloc failed");
- return (NULL);
+ return NULL;
}
/* Push initial key */
if (ds == NULL) {
INFO("utils_lua: Unable to lookup type \"%s\".", vl->type);
sfree(vl);
- return (NULL);
+ return NULL;
}
int status = ltoc_table_values(L, idx, ds, vl);
if (status != 0) {
WARNING("utils_lua: ltoc_table_values failed.");
sfree(vl);
- return (NULL);
+ return NULL;
}
#if COLLECT_DEBUG
assert(stack_top_before == lua_gettop(L));
#endif
- return (vl);
+ return vl;
} /* }}} value_list_t *luaC_tovaluelist */
int luaC_pushcdtime(lua_State *L, cdtime_t t) /* {{{ */
double d = CDTIME_T_TO_DOUBLE(t);
lua_pushnumber(L, (lua_Number)d);
- return (0);
+ return 0;
} /* }}} int luaC_pushcdtime */
int luaC_pushvalue(lua_State *L, value_t v, int ds_type) /* {{{ */
else if (ds_type == DS_TYPE_ABSOLUTE)
lua_pushinteger(L, (lua_Integer)v.absolute);
else
- return (-1);
- return (0);
+ return -1;
+ return 0;
} /* }}} int luaC_pushvalue */
int luaC_pushvaluelist(lua_State *L, const data_set_t *ds,
luaC_pushcdtime(L, vl->interval);
lua_setfield(L, -2, "interval");
- return (0);
+ return 0;
} /* }}} int luaC_pushvaluelist */
diff --git a/src/utils_match.c b/src/utils_match.c
index e8add2d800f130f0d9273d92065573e4ad503a40..df70fbecc366ed62b4b7ffad953aa817bac00be5 100644 (file)
--- a/src/utils_match.c
+++ b/src/utils_match.c
size_t ret_len;
if ((begin < 0) || (end < 0) || (begin >= end))
- return (NULL);
+ return NULL;
if ((size_t)end > (strlen(str) + 1)) {
ERROR("utils_match: match_substr: `end' points after end of string.");
- return (NULL);
+ return NULL;
}
ret_len = end - begin;
ret = malloc(ret_len + 1);
if (ret == NULL) {
ERROR("utils_match: match_substr: malloc failed.");
- return (NULL);
+ return NULL;
}
sstrncpy(ret, str + begin, ret_len + 1);
- return (ret);
+ return ret;
} /* char *match_substr */
static int default_callback(const char __attribute__((unused)) * str,
if (data->ds_type & UTILS_MATCH_CF_GAUGE_INC) {
data->value.gauge = isnan(data->value.gauge) ? 1 : data->value.gauge + 1;
data->values_num++;
- return (0);
+ return 0;
}
if (matches_num < 2)
- return (-1);
+ return -1;
value = (gauge_t)strtod(matches[1], &endptr);
if (matches[1] == endptr)
- return (-1);
+ return -1;
if (data->ds_type & UTILS_MATCH_CF_GAUGE_DIST) {
latency_counter_add(data->latency, DOUBLE_TO_CDTIME_T(value));
data->values_num++;
- return (0);
+ return 0;
}
if ((data->values_num == 0) ||
data->value.gauge += value;
} else {
ERROR("utils_match: default_callback: obj->ds_type is invalid!");
- return (-1);
+ return -1;
}
data->values_num++;
if (data->ds_type & UTILS_MATCH_CF_COUNTER_INC) {
data->value.counter++;
data->values_num++;
- return (0);
+ return 0;
}
if (matches_num < 2)
- return (-1);
+ return -1;
value = (counter_t)strtoull(matches[1], &endptr, 0);
if (matches[1] == endptr)
- return (-1);
+ return -1;
if (data->ds_type & UTILS_MATCH_CF_COUNTER_SET)
data->value.counter = value;
data->value.counter += value;
else {
ERROR("utils_match: default_callback: obj->ds_type is invalid!");
- return (-1);
+ return -1;
}
data->values_num++;
if (data->ds_type & UTILS_MATCH_CF_DERIVE_INC) {
data->value.derive++;
data->values_num++;
- return (0);
+ return 0;
}
if (matches_num < 2)
- return (-1);
+ return -1;
value = (derive_t)strtoll(matches[1], &endptr, 0);
if (matches[1] == endptr)
- return (-1);
+ return -1;
if (data->ds_type & UTILS_MATCH_CF_DERIVE_SET)
data->value.derive = value;
data->value.derive += value;
else {
ERROR("utils_match: default_callback: obj->ds_type is invalid!");
- return (-1);
+ return -1;
}
data->values_num++;
char *endptr = NULL;
if (matches_num < 2)
- return (-1);
+ return -1;
value = (absolute_t)strtoull(matches[1], &endptr, 0);
if (matches[1] == endptr)
- return (-1);
+ return -1;
if (data->ds_type & UTILS_MATCH_CF_ABSOLUTE_SET)
data->value.absolute = value;
else {
ERROR("utils_match: default_callback: obj->ds_type is invalid!");
- return (-1);
+ return -1;
}
data->values_num++;
} else {
ERROR("utils_match: default_callback: obj->ds_type is invalid!");
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int default_callback */
static void match_simple_free(void *data) {
obj = calloc(1, sizeof(*obj));
if (obj == NULL)
- return (NULL);
+ return NULL;
status = regcomp(&obj->regex, regex, REG_EXTENDED | REG_NEWLINE);
if (status != 0) {
ERROR("Compiling the regular expression \"%s\" failed.", regex);
sfree(obj);
- return (NULL);
+ return NULL;
}
obj->flags |= UTILS_MATCH_FLAGS_REGEX;
ERROR("Compiling the excluding regular expression \"%s\" failed.",
excluderegex);
sfree(obj);
- return (NULL);
+ return NULL;
}
obj->flags |= UTILS_MATCH_FLAGS_EXCLUDE_REGEX;
}
obj->user_data = user_data;
obj->free = free_user_data;
- return (obj);
+ return obj;
} /* cu_match_t *match_create_callback */
cu_match_t *match_create_simple(const char *regex, const char *excluderegex,
user_data = calloc(1, sizeof(*user_data));
if (user_data == NULL)
- return (NULL);
+ return NULL;
user_data->ds_type = match_ds_type;
if ((match_ds_type & UTILS_MATCH_DS_TYPE_GAUGE) &&
if (user_data->latency == NULL) {
ERROR("match_create_simple(): latency_counter_create() failed.");
free(user_data);
- return (NULL);
+ return NULL;
}
}
latency_counter_destroy(user_data->latency);
sfree(user_data);
- return (NULL);
+ return NULL;
}
- return (obj);
+ return obj;
} /* cu_match_t *match_create_simple */
void match_value_reset(cu_match_value_t *mv) {
size_t matches_num;
if ((obj == NULL) || (str == NULL))
- return (-1);
+ return -1;
if (obj->flags & UTILS_MATCH_FLAGS_EXCLUDE_REGEX) {
status =
/* Regex did match, so exclude this line */
if (status == 0) {
DEBUG("ExludeRegex matched, don't count that line\n");
- return (0);
+ return 0;
}
}
/* Regex did not match */
if (status != 0)
- return (0);
+ return 0;
for (matches_num = 0; matches_num < STATIC_ARRAY_SIZE(matches);
matches_num++) {
sfree(matches[i]);
}
- return (status);
+ return status;
} /* int match_apply */
void *match_get_user_data(cu_match_t *obj) {
if (obj == NULL)
- return (NULL);
- return (obj->user_data);
+ return NULL;
+ return obj->user_data;
} /* void *match_get_user_data */
diff --git a/src/utils_mount.c b/src/utils_mount.c
index 87f26df04f44b8319f5470e1f15ce9e5cd11f9ab..bbc4c209dcf8a3c6b201bbfce35798fd4ee5c1e3 100644 (file)
--- a/src/utils_mount.c
+++ b/src/utils_mount.c
static unsigned char fromhex(char c) {
if (isdigit((int)c)) {
- return (c - '0');
+ return c - '0';
} else if (islower((int)c)) {
- return (c - 'a' + 10);
+ return c - 'a' + 10;
} else {
- return (c - 'A' + 10);
+ return c - 'A' + 10;
}
}
char *rc;
if (optstr == NULL) {
- return (NULL);
+ return NULL;
} else if (strncmp(optstr, "UUID=", 5) == 0) {
DEBUG("utils_mount: TODO: check UUID= code!");
rc = get_spec_by_uuid(optstr + 5);
last->next = NULL;
} /* for(p = mntlist; p; p = p->next) */
- return (last);
+ return last;
} /* cu_mount_t *cu_mount_listmntent(void) */
/* #endif HAVE_LISTMNTENT */
DEBUG("utils_mount: getv?fsstat failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
#endif /* COLLECT_DEBUG */
- return (NULL);
+ return NULL;
}
if ((buf = calloc(bufsize, sizeof(*buf))) == NULL)
- return (NULL);
+ return NULL;
/* The bufsize needs to be passed in bytes. Really. This is not in the
* manpage.. -octo */
sstrerror(errno, errbuf, sizeof(errbuf)));
#endif /* COLLECT_DEBUG */
free(buf);
- return (NULL);
+ return NULL;
}
for (int i = 0; i < num; i++) {
free(buf);
- return (first);
+ return first;
}
/* #endif HAVE_GETVFSSTAT || HAVE_GETFSSTAT */
char errbuf[1024];
ERROR("fopen (%s): %s", COLLECTD_MNTTAB,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (NULL);
+ return NULL;
}
while (getmntent(fp, &mt) == 0) {
fclose(fp);
- return (first);
+ return first;
} /* static cu_mount_t *cu_mount_gen_getmntent (void) */
/* #endif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT */
char errbuf[1024];
ERROR("setmntent (%s): %s", COLLECTD_MNTTAB,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (NULL);
+ return NULL;
}
while (getmntent_r(fp, &me, mntbuf, sizeof(mntbuf))) {
endmntent(fp);
- DEBUG("utils_mount: return (0x%p)", (void *)first);
+ DEBUG("utils_mount: return 0x%p", (void *)first);
- return (first);
+ return first;
} /* HAVE_GETMNTENT_R */
#elif HAVE_ONE_GETMNTENT
char errbuf[1024];
ERROR("setmntent (%s): %s", COLLECTD_MNTTAB,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (NULL);
+ return NULL;
}
while ((me = getmntent(fp)) != NULL) {
endmntent(fp);
- DEBUG("utils_mount: return (0x%p)", (void *)first);
+ DEBUG("utils_mount: return 0x%p", (void *)first);
- return (first);
+ return first;
}
#endif /* HAVE_ONE_GETMNTENT */
cu_mount_t *last = NULL;
if (list == NULL)
- return (NULL);
+ return NULL;
if (*list != NULL) {
first = *list;
while ((last != NULL) && (last->next != NULL))
last = last->next;
- return (last);
+ return last;
} /* cu_mount_t *cu_mount_getlist(cu_mount_t **list) */
void cu_mount_freelist(cu_mount_t *list) {
diff --git a/src/utils_mount_test.c b/src/utils_mount_test.c
index 76fc8d4a35f41dda4dfe1181dbcab78c5f0e229a..ca65950ebffee08828b20d85a409debef23e28bc 100644 (file)
--- a/src/utils_mount_test.c
+++ b/src/utils_mount_test.c
OK(NULL == cu_mount_checkoption(line_bool, "tw", 1));
OK(NULL == cu_mount_checkoption(line_bool, "thr", 1));
- return (0);
+ return 0;
}
DEF_TEST(cu_mount_getoptionvalue) {
char line_opts[] = "foo=one,bar=two,qux=three";
OK(NULL == (v = cu_mount_getoptionvalue(line_bool, "four")));
sfree(v);
- return (0);
+ return 0;
}
int main(void) {
diff --git a/src/utils_ovs.c b/src/utils_ovs.c
index 65e667950a04452e9234003ba2c6bba56a88b05f..2f7baea00129df218df3e8bf1cdce29d1a36d686 100644 (file)
--- a/src/utils_ovs.c
+++ b/src/utils_ovs.c
pthread_mutex_lock(&pdb->poll_thread.mutex);
state = pdb->poll_thread.state;
pthread_mutex_unlock(&pdb->poll_thread.mutex);
- return (state == OVS_DB_POLL_STATE_RUNNING);
+ return state == OVS_DB_POLL_STATE_RUNNING;
}
/* Generate unique identifier (UID). It is used by OVS DB API
@@ -293,11 +293,11 @@ static int ovs_db_data_send(const ovs_db_t *pdb, const char *data, size_t len) {
while (rem > 0) {
if ((nbytes = send(pdb->sock, data + off, rem, 0)) <= 0)
- return (-1);
+ return -1;
rem -= (size_t)nbytes;
off += (size_t)nbytes;
}
- return (0);
+ return 0;
}
/*
@@ -314,7 +314,8 @@ static int ovs_db_data_send(const ovs_db_t *pdb, const char *data, size_t len) {
*/
static yajl_gen_status ovs_yajl_gen_tstring(yajl_gen hander,
const char *string) {
- return yajl_gen_string(hander, (const unsigned char *)string, strlen(string));
+ return yajl_gen_string(hander, (const unsigned char *)string,
+ strlen(string));
}
/* Add YAJL value into YAJL generator handle (JSON object)
yajl_gen_status yajl_gen_ret;
if ((jgen = yajl_gen_alloc(NULL)) == NULL)
- return (-1);
+ return -1;
/* check & get request attributes */
if ((jparams = yajl_tree_get(jnode, params_path, yajl_t_array)) == NULL ||
}
/* clean up and return success */
yajl_gen_clear(jgen);
- return (0);
+ return 0;
yajl_gen_failure:
/* release memory */
yajl_gen_clear(jgen);
- return (-1);
+ return -1;
}
/* Get OVS DB registered callback by YAJL val. The YAJL
if ((jparams = yajl_tree_get(jnode, params_path, yajl_t_array)) == NULL ||
(yajl_tree_get(jnode, id_path, yajl_t_null) == NULL)) {
OVS_ERROR("invalid OVS DB request received");
- return (-1);
+ return -1;
}
/* check array length: [<json-value>, <table-updates>] */
if ((YAJL_GET_ARRAY(jparams) == NULL) ||
(YAJL_GET_ARRAY(jparams)->len != 2)) {
OVS_ERROR("invalid OVS DB request received");
- return (-1);
+ return -1;
}
jvalue = YAJL_GET_ARRAY(jparams)->values[0];
jtable_updates = YAJL_GET_ARRAY(jparams)->values[1];
if ((!YAJL_IS_OBJECT(jtable_updates)) || (!YAJL_IS_STRING(jvalue))) {
OVS_ERROR("invalid OVS DB request id or table update received");
- return (-1);
+ return -1;
}
/* find registered callback based on <json-value> */
if (cb == NULL || cb->table.call == NULL) {
OVS_ERROR("No OVS DB table update callback found");
pthread_mutex_unlock(&pdb->mutex);
- return (-1);
+ return -1;
}
/* call registered callback */
/* check & get result attributes */
if (!jresult || !jerror || !jid)
- return (-1);
+ return -1;
/* try to find registered callback */
pthread_mutex_lock(&pdb->mutex);
}
pthread_mutex_unlock(&pdb->mutex);
- return (0);
+ return 0;
}
/* Handle JSON data (one request) and call
/* duplicate the data to make null-terminated string
* required for yajl_tree_parse() */
if ((sjson = calloc(1, len + 1)) == NULL)
- return (-1);
+ return -1;
sstrncpy(sjson, data, len + 1);
OVS_DEBUG("[len=%zu] %s", len, sjson);
if (jnode == NULL) {
OVS_ERROR("yajl_tree_parse() %s", yajl_errbuf);
sfree(sjson);
- return (-1);
+ return -1;
}
/* get method name */
if ((method = YAJL_GET_STRING(jval)) == NULL) {
yajl_tree_free(jnode);
sfree(sjson);
- return (-1);
+ return -1;
}
if (strcmp("echo", method) == 0) {
/* echo request from the server */
/* release memory */
yajl_tree_free(jnode);
sfree(sjson);
- return (0);
+ return 0;
}
/*
/* allocate new chunk of memory */
new_buff = realloc(jreader->buff_ptr, (jreader->buff_size + data_len));
if (new_buff == NULL)
- return (-1);
+ return -1;
/* point to new allocated memory */
jreader->buff_ptr = new_buff;
/* store input data */
memcpy(jreader->buff_ptr + jreader->buff_offset, data, data_len);
jreader->buff_offset += data_len;
- return (0);
+ return 0;
}
/* Pop one fully-fledged JSON if already exists. Returns 0 if
*json_ptr = jreader->buff_ptr + jreader->json_offset;
*json_len_ptr = json_len + 1;
jreader->json_offset = i + 1;
- return (0);
+ return 0;
}
/* increase JSON data length */
jreader->json_offset = 0;
}
- return (-1);
+ return -1;
}
/* Reset JSON reader. It is useful when start processing
/* create JSON reader instance */
if ((jreader = ovs_json_reader_alloc()) == NULL) {
OVS_ERROR("initialize json reader failed");
- return (NULL);
+ return NULL;
}
/* poll data */
OVS_DEBUG("poll thread has been completed");
ovs_json_reader_free(jreader);
- return (NULL);
+ return NULL;
}
/* EVENT worker thread.
}
OVS_DEBUG("event thread has been completed");
- return (NULL);
+ return NULL;
}
/* Initialize EVENT thread */
pdb->event_thread.tid = (pthread_t)-1;
/* init event thread condition variable */
if (pthread_cond_init(&pdb->event_thread.cond, NULL)) {
- return (-1);
+ return -1;
}
/* init event thread mutex */
if (pthread_mutex_init(&pdb->event_thread.mutex, NULL)) {
pthread_cond_destroy(&pdb->event_thread.cond);
- return (-1);
+ return -1;
}
/* Hold the event thread mutex. It ensures that no events
* will be lost while thread is still starting. Once event
if (pthread_mutex_lock(&pdb->event_thread.mutex)) {
pthread_mutex_destroy(&pdb->event_thread.mutex);
pthread_cond_destroy(&pdb->event_thread.cond);
- return (-1);
+ return -1;
}
/* start event thread */
pthread_t tid;
pthread_mutex_unlock(&pdb->event_thread.mutex);
pthread_mutex_destroy(&pdb->event_thread.mutex);
pthread_cond_destroy(&pdb->event_thread.cond);
- return (-1);
+ return -1;
}
pdb->event_thread.tid = tid;
- return (0);
+ return 0;
}
/* Destroy EVENT thread */
static int ovs_db_event_thread_destroy(ovs_db_t *pdb) {
if (pdb->event_thread.tid == (pthread_t)-1)
/* already destroyed */
- return (0);
+ return 0;
ovs_db_event_post(pdb, OVS_DB_EVENT_TERMINATE);
if (pthread_join(pdb->event_thread.tid, NULL) != 0)
- return (-1);
+ return -1;
/* Event thread always holds the thread mutex when
* performs some task (handles event) and releases it when
* while sleeping. Thus, if event thread exits, the mutex
pthread_mutex_destroy(&pdb->event_thread.mutex);
pthread_cond_destroy(&pdb->event_thread.cond);
pdb->event_thread.tid = (pthread_t)-1;
- return (0);
+ return 0;
}
/* Initialize POLL thread */
pdb->poll_thread.tid = (pthread_t)-1;
/* init event thread mutex */
if (pthread_mutex_init(&pdb->poll_thread.mutex, NULL)) {
- return (-1);
+ return -1;
}
/* start poll thread */
pthread_t tid;
if (plugin_thread_create(&tid, NULL, ovs_poll_worker, pdb,
"utils_ovs:poll") != 0) {
pthread_mutex_destroy(&pdb->poll_thread.mutex);
- return (-1);
+ return -1;
}
pdb->poll_thread.tid = tid;
- return (0);
+ return 0;
}
/* Destroy POLL thread */
static int ovs_db_poll_thread_destroy(ovs_db_t *pdb) {
if (pdb->poll_thread.tid == (pthread_t)-1)
/* already destroyed */
- return (0);
+ return 0;
/* change thread state */
pthread_mutex_lock(&pdb->poll_thread.mutex);
pdb->poll_thread.state = OVS_DB_POLL_STATE_EXITING;
pthread_mutex_unlock(&pdb->poll_thread.mutex);
/* join the thread */
if (pthread_join(pdb->poll_thread.tid, NULL) != 0)
- return (-1);
+ return -1;
pthread_mutex_destroy(&pdb->poll_thread.mutex);
pdb->poll_thread.tid = (pthread_t)-1;
- return (0);
+ return 0;
}
/*
const char *unix_path, ovs_db_callback_t *cb) {
/* sanity check */
if (node == NULL || service == NULL || unix_path == NULL)
- return (NULL);
+ return NULL;
/* allocate db data & fill it */
ovs_db_t *pdb = pdb = calloc(1, sizeof(*pdb));
if (pdb == NULL)
- return (NULL);
+ return NULL;
/* store the OVS DB address */
sstrncpy(pdb->node, node, sizeof(pdb->node));
if (pthread_mutexattr_init(&mutex_attr)) {
OVS_ERROR("OVS DB mutex attribute init failed");
sfree(pdb);
- return (NULL);
+ return NULL;
}
/* set OVS DB mutex as recursive */
if (pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE)) {
OVS_ERROR("Failed to set OVS DB mutex as recursive");
pthread_mutexattr_destroy(&mutex_attr);
sfree(pdb);
- return (NULL);
+ return NULL;
}
/* init OVS DB mutex */
if (pthread_mutex_init(&pdb->mutex, &mutex_attr)) {
OVS_ERROR("OVS DB mutex init failed");
pthread_mutexattr_destroy(&mutex_attr);
sfree(pdb);
- return (NULL);
+ return NULL;
}
/* destroy mutex attributes */
pthread_mutexattr_destroy(&mutex_attr);
/* init event thread */
if (ovs_db_event_thread_init(pdb) < 0) {
ovs_db_destroy(pdb);
- return (NULL);
+ return NULL;
}
/* init polling thread */
pdb->sock = -1;
if (ovs_db_poll_thread_init(pdb) < 0) {
ovs_db_destroy(pdb);
- return (NULL);
+ return NULL;
}
return pdb;
}
@@ -1064,16 +1065,16 @@ int ovs_db_send_request(ovs_db_t *pdb, const char *method, const char *params,
/* sanity check */
if (!pdb || !method || !params)
- return (-1);
+ return -1;
if ((jgen = yajl_gen_alloc(NULL)) == NULL)
- return (-1);
+ return -1;
/* try to parse params */
if ((jparams = yajl_tree_parse(params, NULL, 0)) == NULL) {
OVS_ERROR("params is not a JSON string");
yajl_gen_clear(jgen);
- return (-1);
+ return -1;
}
/* generate method field */
/* sanity check */
if (pdb == NULL || tb_name == NULL || update_cb == NULL)
- return (-1);
+ return -1;
/* allocate new update callback */
if ((new_cb = calloc(1, sizeof(ovs_callback_t))) == NULL)
- return (-1);
+ return -1;
/* init YAJL generator */
if ((jgen = yajl_gen_alloc(NULL)) == NULL) {
sfree(new_cb);
- return (-1);
+ return -1;
}
/* add new callback to front */
/* sanity check */
if (pdb == NULL)
- return (-1);
+ return -1;
/* try to lock the structure before releasing */
if ((ret = pthread_mutex_lock(&pdb->mutex))) {
OVS_ERROR("pthread_mutex_lock() DB mutex lock failed (%d)", ret);
- return (-1);
+ return -1;
}
/* stop poll thread */
index a2a7380906fe0a89136b3d2b553aa227bb58b4ee..005715c9b1b4c81e7fa2a83e5441970255799ab0 100644 (file)
--- a/src/utils_parse_option.c
+++ b/src/utils_parse_option.c
while (isspace((int)*string))
string++;
if (*string == 0)
- return (1);
+ return 1;
/* A quoted string */
if (*string == '"') {
string++;
if (*string == 0)
- return (1);
+ return 1;
dst = string;
buffer = string;
buffer++;
/* Catch a backslash at the end of buffer */
if (*buffer == 0)
- return (-1);
+ return -1;
}
*dst = *buffer;
buffer++;
}
/* No quote sign has been found */
if (*buffer == 0)
- return (-1);
+ return -1;
*dst = 0;
dst++;
/* Check for trailing spaces. */
if ((*buffer != 0) && !isspace((int)*buffer))
- return (-1);
+ return -1;
} else /* an unquoted string */
{
buffer = string;
*ret_buffer = buffer;
*ret_string = string;
- return (0);
+ return 0;
} /* int parse_string */
/*
while (isspace((int)*key))
key++;
if (*key == 0)
- return (1);
+ return 1;
/* Look for the equal sign */
buffer = key;
while (isalnum((int)*buffer) || *buffer == '_' || *buffer == ':')
buffer++;
if ((*buffer != '=') || (buffer == key))
- return (1);
+ return 1;
*buffer = 0;
buffer++;
/* Empty values must be written as "" */
if (isspace((int)*buffer) || (*buffer == 0))
- return (-1);
+ return -1;
status = parse_string(&buffer, &value);
if (status != 0)
- return (-1);
+ return -1;
/* NB: parse_string will have eaten up all trailing spaces. */
*ret_key = key;
*ret_value = value;
- return (0);
+ return 0;
} /* int parse_option */
diff --git a/src/utils_rrdcreate.c b/src/utils_rrdcreate.c
index ae72575cb85c69ef0c76b0ea753ce4b578965673..86f7f3fbaace5f9929929a1471e8c342669e4511 100644 (file)
--- a/src/utils_rrdcreate.c
+++ b/src/utils_rrdcreate.c
args = calloc(1, sizeof(*args));
if (args == NULL) {
ERROR("srrd_create_args_create: calloc failed.");
- return (NULL);
+ return NULL;
}
args->filename = NULL;
args->pdp_step = pdp_step;
if (args->filename == NULL) {
ERROR("srrd_create_args_create: strdup failed.");
srrd_create_args_destroy(args);
- return (NULL);
+ return NULL;
}
args->argv = calloc((size_t)(argc + 1), sizeof(*args->argv));
if (args->argv == NULL) {
ERROR("srrd_create_args_create: calloc failed.");
srrd_create_args_destroy(args);
- return (NULL);
+ return NULL;
}
for (args->argc = 0; args->argc < argc; args->argc++) {
if (args->argv[args->argc] == NULL) {
ERROR("srrd_create_args_create: strdup failed.");
srrd_create_args_destroy(args);
- return (NULL);
+ return NULL;
}
}
assert(args->argc == argc);
args->argv[args->argc] = NULL;
- return (args);
+ return args;
} /* srrd_create_args_t *srrd_create_args_create */
/* * * * * * * * * *
if (cfg->rrarows <= 0) {
*ret = NULL;
- return (-1);
+ return -1;
}
if ((cfg->xff < 0) || (cfg->xff >= 1.0)) {
*ret = NULL;
- return (-1);
+ return -1;
}
if (cfg->stepsize > 0)
ss = (int)CDTIME_T_TO_TIME_T(vl->interval);
if (ss <= 0) {
*ret = NULL;
- return (-1);
+ return -1;
}
/* Use the configured timespans or fall back to the built-in defaults */
assert(rra_max > 0);
if ((rra_def = calloc(rra_max + 1, sizeof(*rra_def))) == NULL)
- return (-1);
+ return -1;
rra_num = 0;
cdp_len = 0;
if (rra_num <= 0) {
sfree(rra_def);
- return (0);
+ return 0;
}
*ret = rra_def;
- return (rra_num);
+ return rra_num;
} /* }}} int rra_get */
static void ds_free(int ds_num, char **ds_def) /* {{{ */
char errbuf[1024];
ERROR("rrdtool plugin: calloc failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
for (ds_num = 0; ds_num < ds->ds_num; ds_num++) {
if (ds_num != ds->ds_num) {
ds_free(ds_num, ds_def);
- return (-1);
+ return -1;
}
if (ds_num == 0) {
sfree(ds_def);
- return (0);
+ return 0;
}
*ret = ds_def;
- return (ds_num);
+ return ds_num;
} /* }}} int ds_get */
#if HAVE_THREADSAFE_LIBRRD
char *filename_copy;
if ((filename == NULL) || (argv == NULL))
- return (-EINVAL);
+ return -EINVAL;
/* Some versions of librrd don't have the `const' qualifier for the first
* argument, so we have to copy the pointer here to avoid warnings. It sucks,
filename_copy = strdup(filename);
if (filename_copy == NULL) {
ERROR("srrd_create: strdup failed.");
- return (-ENOMEM);
+ return -ENOMEM;
}
optind = 0; /* bug in librrd? */
sfree(filename_copy);
- return (status);
+ return status;
} /* }}} int srrd_create */
/* #endif HAVE_THREADSAFE_LIBRRD */
new_argv = malloc((new_argc + 1) * sizeof(*new_argv));
if (new_argv == NULL) {
ERROR("rrdtool plugin: malloc failed.");
- return (-1);
+ return -1;
}
if (last_up == 0)
sfree(new_argv);
- return (status);
+ return status;
} /* }}} int srrd_create */
#endif /* !HAVE_THREADSAFE_LIBRRD */
if (ptr != NULL) {
pthread_mutex_unlock(&async_creation_lock);
- return (EEXIST);
+ return EEXIST;
}
status = stat(filename, &sb);
if ((status == 0) || (errno != ENOENT)) {
pthread_mutex_unlock(&async_creation_lock);
- return (EEXIST);
+ return EEXIST;
}
ptr = malloc(sizeof(*ptr));
if (ptr == NULL) {
pthread_mutex_unlock(&async_creation_lock);
- return (ENOMEM);
+ return ENOMEM;
}
ptr->filename = strdup(filename);
if (ptr->filename == NULL) {
pthread_mutex_unlock(&async_creation_lock);
sfree(ptr);
- return (ENOMEM);
+ return ENOMEM;
}
ptr->next = async_creation_list;
pthread_mutex_unlock(&async_creation_lock);
- return (0);
+ return 0;
} /* }}} int lock_file */
static int unlock_file(char const *filename) /* {{{ */
if (this == NULL) {
pthread_mutex_unlock(&async_creation_lock);
- return (ENOENT);
+ return ENOENT;
}
if (prev == NULL) {
sfree(this->filename);
sfree(this);
- return (0);
+ return 0;
} /* }}} int unlock_file */
static void *srrd_create_thread(void *targs) /* {{{ */
else
ERROR("srrd_create_thread: Unable to lock file \"%s\".", args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
}
ssnprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
unlink(tmpfile);
unlock_file(args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
}
status = rename(tmpfile, args->filename);
unlink(tmpfile);
unlock_file(args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
}
DEBUG("srrd_create_thread: Successfully created RRD file \"%s\".",
unlock_file(args->filename);
srrd_create_args_destroy(args);
- return (0);
+ return 0;
} /* }}} void *srrd_create_thread */
static int srrd_create_async(const char *filename, /* {{{ */
args = srrd_create_args_create(filename, pdp_step, last_up, argc, argv);
if (args == NULL)
- return (-1);
+ return -1;
status = pthread_attr_init(&attr);
if (status != 0) {
srrd_create_args_destroy(args);
- return (-1);
+ return -1;
}
status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (status != 0) {
pthread_attr_destroy(&attr);
srrd_create_args_destroy(args);
- return (-1);
+ return -1;
}
status = pthread_create(&thread, &attr, srrd_create_thread, args);
sstrerror(status, errbuf, sizeof(errbuf)));
pthread_attr_destroy(&attr);
srrd_create_args_destroy(args);
- return (status);
+ return status;
}
pthread_attr_destroy(&attr);
/* args is freed in srrd_create_thread(). */
- return (0);
+ return 0;
} /* }}} int srrd_create_async */
/*
unsigned long stepsize;
if (check_create_dir(filename))
- return (-1);
+ return -1;
if ((rra_num = rra_get(&rra_def, vl, cfg)) < 1) {
ERROR("cu_rrd_create_file failed: Could not calculate RRAs");
- return (-1);
+ return -1;
}
if ((ds_num = ds_get(&ds_def, ds, vl, cfg)) < 1) {
ERROR("cu_rrd_create_file failed: Could not calculate DSes");
rra_free(rra_num, rra_def);
- return (-1);
+ return -1;
}
argc = ds_num + rra_num;
sstrerror(errno, errbuf, sizeof(errbuf)));
rra_free(rra_num, rra_def);
ds_free(ds_num, ds_def);
- return (-1);
+ return -1;
}
memcpy(argv, ds_def, ds_num * sizeof(char *));
ds_free(ds_num, ds_def);
rra_free(rra_num, rra_def);
- return (status);
+ return status;
} /* }}} int cu_rrd_create_file */
diff --git a/src/utils_tail.c b/src/utils_tail.c
index 565a224c920df8f661488f17a8bd96e8cfb2245a..cdab6a77af8a33de9f1f45d5124b6c644e1ca997 100644 (file)
--- a/src/utils_tail.c
+++ b/src/utils_tail.c
char errbuf[1024];
ERROR("utils_tail: stat (%s) failed: %s", obj->file,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
/* The file is already open.. */
sstrerror(errno, errbuf, sizeof(errbuf)));
fclose(obj->fh);
obj->fh = NULL;
- return (-1);
+ return -1;
}
}
memcpy(&obj->stat, &stat_buf, sizeof(struct stat));
- return (1);
+ return 1;
}
/* Seek to the end if we re-open the same file again or the file opened
char errbuf[1024];
ERROR("utils_tail: fopen (%s) failed: %s", obj->file,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
if (seek_end != 0) {
ERROR("utils_tail: fseek (%s) failed: %s", obj->file,
sstrerror(errno, errbuf, sizeof(errbuf)));
fclose(fh);
- return (-1);
+ return -1;
}
}
obj->fh = fh;
memcpy(&obj->stat, &stat_buf, sizeof(struct stat));
- return (0);
+ return 0;
} /* int cu_tail_reopen */
cu_tail_t *cu_tail_create(const char *file) {
obj = calloc(1, sizeof(*obj));
if (obj == NULL)
- return (NULL);
+ return NULL;
obj->file = strdup(file);
if (obj->file == NULL) {
free(obj);
- return (NULL);
+ return NULL;
}
obj->fh = NULL;
- return (obj);
+ return obj;
} /* cu_tail_t *cu_tail_create */
int cu_tail_destroy(cu_tail_t *obj) {
free(obj->file);
free(obj);
- return (0);
+ return 0;
} /* int cu_tail_destroy */
int cu_tail_readline(cu_tail_t *obj, char *buf, int buflen) {
if (buflen < 1) {
ERROR("utils_tail: cu_tail_readline: buflen too small: %i bytes.", buflen);
- return (-1);
+ return -1;
}
if (obj->fh == NULL) {
status = cu_tail_reopen(obj);
if (status < 0)
- return (status);
+ return status;
}
assert(obj->fh != NULL);
clearerr(obj->fh);
if (fgets(buf, buflen, obj->fh) != NULL) {
buf[buflen - 1] = 0;
- return (0);
+ return 0;
}
/* Check if we encountered an error */
status = cu_tail_reopen(obj);
/* error -> return with error */
if (status < 0)
- return (status);
+ return status;
/* file end reached and file not reopened -> nothing more to read */
else if (status > 0) {
buf[0] = 0;
- return (0);
+ return 0;
}
/* If we get here: file was re-opened and there may be more to read.. Let's
* try again. */
if (fgets(buf, buflen, obj->fh) != NULL) {
buf[buflen - 1] = 0;
- return (0);
+ return 0;
}
if (ferror(obj->fh) != 0) {
sstrerror(errno, errbuf, sizeof(errbuf)));
fclose(obj->fh);
obj->fh = NULL;
- return (-1);
+ return -1;
}
/* EOf, well, apparently the new file is empty.. */
buf[0] = 0;
- return (0);
+ return 0;
} /* int cu_tail_readline */
int cu_tail_read(cu_tail_t *obj, char *buf, int buflen, tailfunc_t *callback,
diff --git a/src/utils_tail_match.c b/src/utils_tail_match.c
index 1a99384b888adf69a087ac31152efeaad7621ac0..f046f6b1e8d64c547651d6bbee5ff8a942b031cc 100644 (file)
--- a/src/utils_tail_match.c
+++ b/src/utils_tail_match.c
match_value = (cu_match_value_t *)match_get_user_data(match);
if (match_value == NULL)
- return (-1);
+ return -1;
if ((match_value->ds_type & UTILS_MATCH_DS_TYPE_GAUGE) &&
(match_value->values_num == 0))
plugin_dispatch_values(&vl);
match_value_reset(match_value);
- return (0);
+ return 0;
} /* int simple_submit_match */
static int latency_submit_match(cu_match_t *match, void *user_data) {
match_value = (cu_match_value_t *)match_get_user_data(match);
if (match_value == NULL)
- return (-1);
+ return -1;
sstrncpy(vl.host, hostname_g, sizeof(vl.host));
sstrncpy(vl.plugin, data->plugin, sizeof(vl.plugin));
match_value->values_num = 0;
latency_counter_reset(match_value->latency);
- return (0);
+ return 0;
} /* int latency_submit_match */
static int tail_callback(void *data, char *buf,
for (size_t i = 0; i < obj->matches_num; i++)
match_apply(obj->matches[i].match, buf);
- return (0);
+ return 0;
} /* int tail_callback */
static void tail_match_simple_free(void *data) {
obj = calloc(1, sizeof(*obj));
if (obj == NULL)
- return (NULL);
+ return NULL;
obj->tail = cu_tail_create(filename);
if (obj->tail == NULL) {
sfree(obj);
- return (NULL);
+ return NULL;
}
- return (obj);
+ return obj;
} /* cu_tail_match_t *tail_match_create */
void tail_match_destroy(cu_tail_match_t *obj) {
temp = realloc(obj->matches,
sizeof(cu_tail_match_match_t) * (obj->matches_num + 1));
if (temp == NULL)
- return (-1);
+ return -1;
obj->matches = temp;
obj->matches_num++;
temp->submit = submit_match;
temp->free = free_user_data;
- return (0);
+ return 0;
} /* int tail_match_add_match */
int tail_match_add_match_simple(cu_tail_match_t *obj, const char *regex,
match = match_create_simple(regex, excluderegex, ds_type);
if (match == NULL)
- return (-1);
+ return -1;
user_data = calloc(1, sizeof(*user_data));
if (user_data == NULL) {
match_destroy(match);
- return (-1);
+ return -1;
}
sstrncpy(user_data->plugin, plugin, sizeof(user_data->plugin));
match_destroy(match);
}
- return (status);
+ return status;
} /* int tail_match_add_match_simple */
int tail_match_read(cu_tail_match_t *obj) {
(void *)obj);
if (status != 0) {
ERROR("tail_match: cu_tail_read failed.");
- return (status);
+ return status;
}
for (size_t i = 0; i < obj->matches_num; i++) {
(*lt_match->submit)(lt_match->match, lt_match->user_data);
}
- return (0);
+ return 0;
} /* int tail_match_read */
diff --git a/src/utils_vl_lookup.c b/src/utils_vl_lookup.c
index 8bcaf408aab1ce7dda6b880b201d8c51f4972a69..76c0674b8d596e6f0e28eb97830eef9a5a422465 100644 (file)
--- a/src/utils_vl_lookup.c
+++ b/src/utils_vl_lookup.c
if (match->is_regex) {
/* Short cut popular catch-all regex. */
if (strcmp(".*", match->str) == 0)
- return (1);
+ return 1;
int status = regexec(&match->regex, str,
/* nmatch = */ 0, /* pmatch = */ NULL,
/* flags = */ 0);
if (status == 0)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} else if (strcmp(match->str, str) == 0)
- return (1);
+ return 1;
else
- return (0);
+ return 0;
} /* }}} _Bool lu_part_matches */
static int lu_copy_ident_to_match_part(part_match_t *match_part, /* {{{ */
if ((len < 3) || (ident_part[0] != '/') || (ident_part[len - 1] != '/')) {
sstrncpy(match_part->str, ident_part, sizeof(match_part->str));
match_part->is_regex = 0;
- return (0);
+ return 0;
}
/* Copy string without the leading slash. */
regerror(status, &match_part->regex, errbuf, sizeof(errbuf));
ERROR("utils_vl_lookup: Compiling regular expression \"%s\" failed: %s",
match_part->str, errbuf);
- return (EINVAL);
+ return EINVAL;
}
match_part->is_regex = 1;
- return (0);
+ return 0;
} /* }}} int lu_copy_ident_to_match_part */
static int lu_copy_ident_to_match(identifier_match_t *match, /* {{{ */
do { \
int status = lu_copy_ident_to_match_part(&match->field, ident->field); \
if (status != 0) \
- return (status); \
+ return status; \
} while (0)
COPY_FIELD(host);
#undef COPY_FIELD
- return (0);
+ return 0;
} /* }}} int lu_copy_ident_to_match */
/* user_class->lock must be held when calling this function */
user_obj = calloc(1, sizeof(*user_obj));
if (user_obj == NULL) {
ERROR("utils_vl_lookup: calloc failed.");
- return (NULL);
+ return NULL;
}
user_obj->next = NULL;
if (user_obj->user_obj == NULL) {
sfree(user_obj);
WARNING("utils_vl_lookup: User-provided constructor failed.");
- return (NULL);
+ return NULL;
}
#define COPY_FIELD(field, group_mask) \
last->next = user_obj;
}
- return (user_obj);
+ return user_obj;
} /* }}} void *lu_create_user_obj */
/* user_class->lock must be held when calling this function */
(strcmp(vl->type_instance, ptr->ident.type_instance) != 0))
continue;
- return (ptr);
+ return ptr;
}
- return (NULL);
+ return NULL;
} /* }}} user_obj_t *lu_find_user_obj */
static int lu_handle_user_class(lookup_t *obj, /* {{{ */
vl->plugin_instance) ||
!lu_part_matches(&user_class->match.plugin, vl->plugin) ||
!lu_part_matches(&user_class->match.host, vl->host))
- return (1);
+ return 1;
pthread_mutex_lock(&user_class->lock);
user_obj = lu_find_user_obj(user_class, vl);
user_obj = lu_create_user_obj(obj, ds, vl, user_class);
if (user_obj == NULL) {
pthread_mutex_unlock(&user_class->lock);
- return (-1);
+ return -1;
}
}
pthread_mutex_unlock(&user_class->lock);
status);
/* Returning a negative value means: abort! */
if (status < 0)
- return (status);
+ return status;
else
- return (1);
+ return 1;
}
- return (0);
+ return 0;
} /* }}} int lu_handle_user_class */
static int lu_handle_user_class_list(lookup_t *obj, /* {{{ */
status = lu_handle_user_class(obj, ds, vl, &ptr->entry);
if (status < 0)
- return (status);
+ return status;
else if (status == 0)
retval++;
}
- return (retval);
+ return retval;
} /* }}} int lu_handle_user_class_list */
static by_type_entry_t *lu_search_by_type(lookup_t *obj, /* {{{ */
status = c_avl_get(obj->by_type_tree, type, (void *)&by_type);
if (status == 0)
- return (by_type);
+ return by_type;
if (!allocate_if_missing)
- return (NULL);
+ return NULL;
type_copy = strdup(type);
if (type_copy == NULL) {
ERROR("utils_vl_lookup: strdup failed.");
- return (NULL);
+ return NULL;
}
by_type = calloc(1, sizeof(*by_type));
if (by_type == NULL) {
ERROR("utils_vl_lookup: calloc failed.");
sfree(type_copy);
- return (NULL);
+ return NULL;
}
by_type->wildcard_plugin_list = NULL;
ERROR("utils_vl_lookup: c_avl_create failed.");
sfree(by_type);
sfree(type_copy);
- return (NULL);
+ return NULL;
}
status = c_avl_insert(obj->by_type_tree,
c_avl_destroy(by_type->by_plugin_tree);
sfree(by_type);
sfree(type_copy);
- return (NULL);
+ return NULL;
}
- return (by_type);
+ return by_type;
} /* }}} by_type_entry_t *lu_search_by_type */
static int lu_add_by_plugin(by_type_entry_t *by_type, /* {{{ */
if (match->plugin.is_regex) {
if (by_type->wildcard_plugin_list == NULL) {
by_type->wildcard_plugin_list = user_class_list;
- return (0);
+ return 0;
}
ptr = by_type->wildcard_plugin_list;
if (plugin_copy == NULL) {
ERROR("utils_vl_lookup: strdup failed.");
sfree(user_class_list);
- return (ENOMEM);
+ return ENOMEM;
}
status =
plugin_copy, status);
sfree(plugin_copy);
sfree(user_class_list);
- return (status);
+ return status;
} else {
- return (0);
+ return 0;
}
} /* if (plugin not yet in tree) */
} /* if (plugin is not wildcard) */
ptr = ptr->next;
ptr->next = user_class_list;
- return (0);
+ return 0;
} /* }}} int lu_add_by_plugin */
static void lu_destroy_user_obj(lookup_t *obj, /* {{{ */
lookup_t *obj = calloc(1, sizeof(*obj));
if (obj == NULL) {
ERROR("utils_vl_lookup: calloc failed.");
- return (NULL);
+ return NULL;
}
obj->by_type_tree = c_avl_create((int (*)(const void *, const void *))strcmp);
if (obj->by_type_tree == NULL) {
ERROR("utils_vl_lookup: c_avl_create failed.");
sfree(obj);
- return (NULL);
+ return NULL;
}
obj->cb_user_class = cb_user_class;
obj->cb_free_class = cb_free_class;
obj->cb_free_obj = cb_free_obj;
- return (obj);
+ return obj;
} /* }}} lookup_t *lookup_create */
void lookup_destroy(lookup_t *obj) /* {{{ */
by_type = lu_search_by_type(obj, ident->type, /* allocate = */ 1);
if (by_type == NULL)
- return (-1);
+ return -1;
user_class_obj = calloc(1, sizeof(*user_class_obj));
if (user_class_obj == NULL) {
ERROR("utils_vl_lookup: calloc failed.");
- return (ENOMEM);
+ return ENOMEM;
}
pthread_mutex_init(&user_class_obj->entry.lock, /* attr = */ NULL);
user_class_obj->entry.user_class = user_class;
user_class_obj->entry.user_obj_list = NULL;
user_class_obj->next = NULL;
- return (lu_add_by_plugin(by_type, user_class_obj));
+ return lu_add_by_plugin(by_type, user_class_obj);
} /* }}} int lookup_add */
/* returns the number of successful calls to the callback function */
int status;
if ((obj == NULL) || (ds == NULL) || (vl == NULL))
- return (-EINVAL);
+ return -EINVAL;
by_type = lu_search_by_type(obj, vl->type, /* allocate = */ 0);
if (by_type == NULL)
- return (0);
+ return 0;
status =
c_avl_get(by_type->by_plugin_tree, vl->plugin, (void *)&user_class_list);
if (status == 0) {
status = lu_handle_user_class_list(obj, ds, vl, user_class_list);
if (status < 0)
- return (status);
+ return status;
retval += status;
}
status =
lu_handle_user_class_list(obj, ds, vl, by_type->wildcard_plugin_list);
if (status < 0)
- return (status);
+ return status;
retval += status;
}
- return (retval);
+ return retval;
} /* }}} lookup_search */
index 776a520a070cfc4b38aff6f0e07aa28c1cb126f5..058015edb6bd6780d28032743007196d4adae0cd 100644 (file)
memcpy(&last_obj_ident, obj, sizeof(last_obj_ident));
if (strcmp(obj->plugin_instance, "failure") == 0)
- return (-1);
+ return -1;
- return (0);
+ return 0;
}
static void *lookup_class_callback(data_set_t const *ds, value_list_t const *vl,
have_new_obj = 1;
- return ((void *)obj);
+ return (void *)obj;
}
static int checked_lookup_add(lookup_t *obj, /* {{{ */
have_new_obj = 0;
status = lookup_search(obj, ds, &vl);
- return (status);
+ return status;
}
DEF_TEST(group_by_specific_host) {
/* expect new = */ 0);
lookup_destroy(obj);
- return (0);
+ return 0;
}
DEF_TEST(group_by_any_host) {
/* expect new = */ 0);
lookup_destroy(obj);
- return (0);
+ return 0;
}
DEF_TEST(multiple_lookups) {
assert(status == 2);
lookup_destroy(obj);
- return (0);
+ return 0;
}
DEF_TEST(regex) {
/* expect new = */ 1);
lookup_destroy(obj);
- return (0);
+ return 0;
}
int main(int argc, char **argv) /* {{{ */
diff --git a/src/uuid.c b/src/uuid.c
index 546d481d81d8daa5ec116fc857ffc9caa146e919..4846841bb5cc7718b5221f443a0888580007efd8 100644 (file)
--- a/src/uuid.c
+++ b/src/uuid.c
int len;
if (!uuid)
- return (0);
+ return 0;
len = strlen(uuid);
if (len < UUID_PRINTABLE_COMPACT_LENGTH)
- return (0);
+ return 0;
while (*uuid) {
if (!isxdigit((int)*uuid) && *uuid != '-')
- return (0);
+ return 0;
uuid++;
}
- return (1);
+ return 1;
}
static char *uuid_parse_dmidecode(FILE *file) {
if (!looks_like_a_uuid(fields[1]))
continue;
- return (strdup(fields[1]));
+ return strdup(fields[1]);
}
- return (NULL);
+ return NULL;
}
static char *uuid_get_from_dmidecode(void) {
char *uuid;
if (!dmidecode)
- return (NULL);
+ return NULL;
uuid = uuid_parse_dmidecode(dmidecode);
pclose(dmidecode);
- return (uuid);
+ return uuid;
}
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
size_t len = sizeof(uuid);
if (sysctlbyname(name, &uuid, &len, NULL, 0) == -1)
return NULL;
- return (strdup(uuid));
+ return strdup(uuid);
}
#elif defined(__OpenBSD__)
static char *uuid_get_from_sysctl(void) {
if (sysctl(mib, 2, uuid, &len, NULL, 0) == -1)
return NULL;
- return (strdup(uuid));
+ return strdup(uuid);
}
#endif
file = fopen(path, "r");
if (file == NULL)
- return (NULL);
+ return NULL;
if (!fgets(uuid, sizeof(uuid), file)) {
fclose(file);
- return (NULL);
+ return NULL;
}
fclose(file);
strstripnewline(uuid);
- return (strdup(uuid));
+ return strdup(uuid);
}
static char *uuid_get_local(void) {
/* Check /etc/uuid / UUIDFile before any other method. */
if ((uuid = uuid_get_from_file(uuidfile ? uuidfile : "/etc/uuid")) != NULL)
- return (uuid);
+ return uuid;
#if defined(__APPLE__)
if ((uuid = uuid_get_from_sysctlbyname("kern.uuid")) != NULL)
- return (uuid);
+ return uuid;
#elif defined(__FreeBSD__)
if ((uuid = uuid_get_from_sysctlbyname("kern.hostuuid")) != NULL)
- return (uuid);
+ return uuid;
#elif defined(__NetBSD__)
if ((uuid = uuid_get_from_sysctlbyname("machdep.dmi.system-uuid")) != NULL)
- return (uuid);
+ return uuid;
#elif defined(__OpenBSD__)
if ((uuid = uuid_get_from_sysctl()) != NULL)
- return (uuid);
+ return uuid;
#elif defined(__linux__)
if ((uuid = uuid_get_from_file("/sys/class/dmi/id/product_uuid")) != NULL)
- return (uuid);
+ return uuid;
#endif
if ((uuid = uuid_get_from_dmidecode()) != NULL)
- return (uuid);
+ return uuid;
#if defined(__linux__)
if ((uuid = uuid_get_from_file("/sys/hypervisor/uuid")) != NULL)
- return (uuid);
+ return uuid;
#endif
- return (NULL);
+ return NULL;
}
static int uuid_config(const char *key, const char *value) {
if (strcasecmp(key, "UUIDFile") == 0) {
char *tmp = strdup(value);
if (tmp == NULL)
- return (-1);
+ return -1;
sfree(uuidfile);
uuidfile = tmp;
- return (0);
+ return 0;
}
- return (1);
+ return 1;
}
static int uuid_init(void) {
if (uuid) {
sstrncpy(hostname_g, uuid, DATA_MAX_NAME_LEN);
sfree(uuid);
- return (0);
+ return 0;
}
WARNING("uuid: could not read UUID using any known method");
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/varnish.c b/src/varnish.c
index 3538e7e2d2577e2238928607806efc6190ebcc72..1a71d8ce5e42b40987ee7ce49959d87f10df476c 100644 (file)
--- a/src/varnish.c
+++ b/src/varnish.c
if (type_instance != NULL)
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
- return (plugin_dispatch_values(&vl));
+ return plugin_dispatch_values(&vl);
} /* }}} int varnish_submit */
static int varnish_submit_gauge(const char *plugin_instance, /* {{{ */
const char *category, const char *type,
const char *type_instance,
uint64_t gauge_value) {
- return (varnish_submit(plugin_instance, category, type, type_instance,
- (value_t){.gauge = (gauge_t)gauge_value}));
+ return varnish_submit(plugin_instance, category, type, type_instance, (value_t){
+ .gauge=(gauge_t)gauge_value,
+ });
} /* }}} int varnish_submit_gauge */
static int varnish_submit_derive(const char *plugin_instance, /* {{{ */
const char *category, const char *type,
const char *type_instance,
uint64_t derive_value) {
- return (varnish_submit(plugin_instance, category, type, type_instance,
- (value_t){.derive = (derive_t)derive_value}));
+ return varnish_submit(plugin_instance, category, type, type_instance, (value_t){
+ .derive=(derive_t)derive_value,
+ });
} /* }}} int varnish_submit_derive */
#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
const char *name;
if (pt == NULL)
- return (0);
+ return 0;
conf = priv;
name = pt->desc->name;
if (strcmp(class, "MAIN") != 0)
- return (0);
+ return 0;
#elif HAVE_VARNISH_V3
class = pt->class;
name = pt->name;
if (strcmp(class, "") != 0)
- return (0);
+ return 0;
#endif
val = *(const volatile uint64_t *)pt->ptr;
if (conf->collect_connections) {
if (strcmp(name, "client_conn") == 0)
- return varnish_submit_derive(conf->instance, "connections", "connections",
- "accepted", val);
+ return varnish_submit_derive(conf->instance, "connections",
+ "connections", "accepted", val);
else if (strcmp(name, "client_drop") == 0)
- return varnish_submit_derive(conf->instance, "connections", "connections",
- "dropped", val);
+ return varnish_submit_derive(conf->instance, "connections",
+ "connections", "dropped", val);
else if (strcmp(name, "client_req") == 0)
- return varnish_submit_derive(conf->instance, "connections", "connections",
- "received", val);
+ return varnish_submit_derive(conf->instance, "connections",
+ "connections", "received", val);
}
#ifdef HAVE_VARNISH_V3
if (conf->collect_dirdns) {
if (strcmp(name, "dir_dns_lookups") == 0)
- return varnish_submit_derive(conf->instance, "dirdns", "cache_operation",
- "lookups", val);
+ return varnish_submit_derive(conf->instance, "dirdns",
+ "cache_operation", "lookups", val);
else if (strcmp(name, "dir_dns_failed") == 0)
return varnish_submit_derive(conf->instance, "dirdns", "cache_result",
"failed", val);
return varnish_submit_gauge(conf->instance, "sms", "requests",
"outstanding", val);
else if (strcmp(name, "sms_nbytes") == 0)
- return varnish_submit_gauge(conf->instance, "sms", "bytes", "outstanding",
- val);
+ return varnish_submit_gauge(conf->instance, "sms", "bytes",
+ "outstanding", val);
else if (strcmp(name, "sms_balloc") == 0)
return varnish_submit_derive(conf->instance, "sms", "total_bytes",
"allocated", val);
else if (strcmp(name, "sms_bfree") == 0)
- return varnish_submit_derive(conf->instance, "sms", "total_bytes", "free",
- val);
+ return varnish_submit_derive(conf->instance, "sms", "total_bytes",
+ "free", val);
}
if (conf->collect_struct) {
if (strcmp(name, "n_sess_mem") == 0)
- return varnish_submit_gauge(conf->instance, "struct", "current_sessions",
- "sess_mem", val);
+ return varnish_submit_gauge(conf->instance, "struct",
+ "current_sessions", "sess_mem", val);
else if (strcmp(name, "n_sess") == 0)
- return varnish_submit_gauge(conf->instance, "struct", "current_sessions",
- "sess", val);
+ return varnish_submit_gauge(conf->instance, "struct",
+ "current_sessions", "sess", val);
else if (strcmp(name, "n_object") == 0)
- return varnish_submit_gauge(conf->instance, "struct", "objects", "object",
- val);
+ return varnish_submit_gauge(conf->instance, "struct", "objects",
+ "object", val);
else if (strcmp(name, "n_vampireobject") == 0)
return varnish_submit_gauge(conf->instance, "struct", "objects",
"vampireobject", val);
return varnish_submit_derive(conf->instance, "totals", "total_requests",
"requests", val);
else if (strcmp(name, "s_pipe") == 0)
- return varnish_submit_derive(conf->instance, "totals", "total_operations",
- "pipe", val);
+ return varnish_submit_derive(conf->instance, "totals",
+ "total_operations", "pipe", val);
else if (strcmp(name, "s_pass") == 0)
- return varnish_submit_derive(conf->instance, "totals", "total_operations",
- "pass", val);
+ return varnish_submit_derive(conf->instance, "totals",
+ "total_operations", "pass", val);
else if (strcmp(name, "s_fetch") == 0)
- return varnish_submit_derive(conf->instance, "totals", "total_operations",
- "fetches", val);
+ return varnish_submit_derive(conf->instance, "totals",
+ "total_operations", "fetches", val);
else if (strcmp(name, "s_synth") == 0)
return varnish_submit_derive(conf->instance, "totals", "total_bytes",
"synth", val);
return varnish_submit_derive(conf->instance, "totals", "total_bytes",
"pipe_out", val);
else if (strcmp(name, "n_purges") == 0)
- return varnish_submit_derive(conf->instance, "totals", "total_operations",
- "purges", val);
+ return varnish_submit_derive(conf->instance, "totals",
+ "total_operations", "purges", val);
else if (strcmp(name, "s_hdrbytes") == 0)
return varnish_submit_derive(conf->instance, "totals", "total_bytes",
"header-bytes", val);
return varnish_submit_derive(conf->instance, "totals", "total_bytes",
"body-bytes", val);
else if (strcmp(name, "n_gzip") == 0)
- return varnish_submit_derive(conf->instance, "totals", "total_operations",
- "gzip", val);
+ return varnish_submit_derive(conf->instance, "totals",
+ "total_operations", "gzip", val);
else if (strcmp(name, "n_gunzip") == 0)
- return varnish_submit_derive(conf->instance, "totals", "total_operations",
- "gunzip", val);
+ return varnish_submit_derive(conf->instance, "totals",
+ "total_operations", "gunzip", val);
}
if (conf->collect_uptime) {
return varnish_submit_gauge(conf->instance, "vcl", "vcl", "avail_vcl",
val);
else if (strcmp(name, "n_vcl_discard") == 0)
- return varnish_submit_gauge(conf->instance, "vcl", "vcl", "discarded_vcl",
- val);
+ return varnish_submit_gauge(conf->instance, "vcl", "vcl",
+ "discarded_vcl", val);
else if (strcmp(name, "vmods") == 0)
return varnish_submit_gauge(conf->instance, "vcl", "objects", "vmod",
val);
return varnish_submit_derive(conf->instance, "workers", "total_threads",
"dropped", val);
else if (strcmp(name, "n_wrk_queue") == 0)
- return varnish_submit_derive(conf->instance, "workers", "total_requests",
- "queued", val);
+ return varnish_submit_derive(conf->instance, "workers",
+ "total_requests", "queued", val);
else if (strcmp(name, "n_wrk_overflow") == 0)
- return varnish_submit_derive(conf->instance, "workers", "total_requests",
- "overflowed", val);
+ return varnish_submit_derive(conf->instance, "workers",
+ "total_requests", "overflowed", val);
else if (strcmp(name, "n_wrk_queued") == 0)
- return varnish_submit_derive(conf->instance, "workers", "total_requests",
- "queued", val);
+ return varnish_submit_derive(conf->instance, "workers",
+ "total_requests", "queued", val);
else if (strcmp(name, "n_wrk_lqueue") == 0)
- return varnish_submit_derive(conf->instance, "workers", "total_requests",
- "queue_length", val);
+ return varnish_submit_derive(conf->instance, "workers",
+ "total_requests", "queue_length", val);
}
#if HAVE_VARNISH_V4
}
#endif
- return (0);
+ return 0;
} /* }}} static int varnish_monitor */
#else /* if HAVE_VARNISH_V2 */
user_config_t *conf;
if ((ud == NULL) || (ud->data == NULL))
- return (EINVAL);
+ return EINVAL;
conf = ud->data;
ERROR("varnish plugin: VSM_n_Arg (\"%s\") failed "
"with status %i.",
conf->instance, status);
- return (-1);
+ return -1;
}
}
VSM_Delete(vd);
ERROR("varnish plugin: Unable to open connection.");
- return (-1);
+ return -1;
}
#if HAVE_VARNISH_V3
VSM_Delete(vd);
ERROR("varnish plugin: Unable to get statistics.");
- return (-1);
+ return -1;
}
#if HAVE_VARNISH_V3
#endif
VSM_Delete(vd);
- return (0);
+ return 0;
} /* }}} */
#else /* if HAVE_VARNISH_V2 */
static int varnish_read(user_data_t *ud) /* {{{ */
user_config_t *conf;
if ((ud == NULL) || (ud->data == NULL))
- return (EINVAL);
+ return EINVAL;
conf = ud->data;
if (stats == NULL) {
ERROR("Varnish plugin : unable to load statistics");
- return (-1);
+ return -1;
}
varnish_monitor(conf, stats);
- return (0);
+ return 0;
} /* }}} */
#endif
static int varnish_config_apply_default(user_config_t *conf) /* {{{ */
{
if (conf == NULL)
- return (EINVAL);
+ return EINVAL;
conf->collect_backend = 1;
conf->collect_cache = 1;
conf->collect_vsm = 0;
#endif
- return (0);
+ return 0;
} /* }}} int varnish_config_apply_default */
static int varnish_init(void) /* {{{ */
user_config_t *conf;
if (have_instance)
- return (0);
+ return 0;
conf = calloc(1, sizeof(*conf));
if (conf == NULL)
- return (ENOMEM);
+ return ENOMEM;
/* Default settings: */
conf->instance = NULL;
.data = conf, .free_func = varnish_config_free,
});
- return (0);
+ return 0;
} /* }}} int varnish_init */
static int varnish_config_instance(const oconfig_item_t *ci) /* {{{ */
conf = calloc(1, sizeof(*conf));
if (conf == NULL)
- return (ENOMEM);
+ return ENOMEM;
conf->instance = NULL;
varnish_config_apply_default(conf);
status = cf_util_get_string(ci, &conf->instance);
if (status != 0) {
sfree(conf);
- return (status);
+ return status;
}
assert(conf->instance != NULL);
WARNING("Varnish plugin: \"Instance\" blocks accept only "
"one argument.");
sfree(conf);
- return (EINVAL);
+ return EINVAL;
}
for (int i = 0; i < ci->children_num; i++) {
"instance \"%s\". Disabling this instance.",
(conf->instance == NULL) ? "localhost" : conf->instance);
sfree(conf);
- return (EINVAL);
+ return EINVAL;
}
ssnprintf(callback_name, sizeof(callback_name), "varnish/%s",
have_instance = 1;
- return (0);
+ return 0;
} /* }}} int varnish_config_instance */
static int varnish_config(oconfig_item_t *ci) /* {{{ */
}
}
- return (0);
+ return 0;
} /* }}} int varnish_config */
void module_register(void) /* {{{ */
diff --git a/src/vmem.c b/src/vmem.c
index 0d7769b762831813eddc8331c1f6119262b5f672..ffe1826afb981270cb3fcbefe17b279baf647636 100644 (file)
--- a/src/vmem.c
+++ b/src/vmem.c
else
verbose_output = 0;
} else {
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* int vmem_config */
static int vmem_read(void) {
char errbuf[1024];
ERROR("vmem plugin: fopen (/proc/vmstat) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
submit_two(NULL, "vmpage_io", "swap", pswpin, pswpout);
#endif /* KERNEL_LINUX */
- return (0);
+ return 0;
} /* int vmem_read */
void module_register(void) {
diff --git a/src/vserver.c b/src/vserver.c
index 96af6fc8bf2291622934200e78a66e49d9840076..a2ca0de5dfc93109b2a4fa79d4a673b0792ede6b 100644 (file)
--- a/src/vserver.c
+++ b/src/vserver.c
* What's the right thing to do, if there is no getpagesize ()? */
pagesize = getpagesize();
- return (0);
+ return 0;
} /* static void vserver_init(void) */
static void traffic_submit(const char *plugin_instance,
status = parse_value(s, &v, DS_TYPE_DERIVE);
if (status != 0)
- return (-1);
- return (v.derive);
+ return -1;
+ return v.derive;
}
static int vserver_read(void) {
char errbuf[1024];
ERROR("vserver plugin: fopen (%s): %s", PROCDIR,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
while (42) {
ERROR("vserver plugin: failed to read directory %s: %s", PROCDIR,
sstrerror(errno, errbuf, sizeof(errbuf)));
closedir(proc);
- return (-1);
+ return -1;
}
if (dent->d_name[0] == '.')
closedir(proc);
- return (0);
+ return 0;
} /* int vserver_read */
void module_register(void) {
diff --git a/src/wireless.c b/src/wireless.c
index ae77ded869a44bbb64c038ae0103301c93e5705b..5552be640c7896263fb53297cd187fc42b678594 100644 (file)
--- a/src/wireless.c
+++ b/src/wireless.c
watt = pow (10.0, (dbm / 10.0)) / 1000.0;
- return (watt);
+ return watt;
}
#endif
static double wireless_percent_to_power(double quality) {
assert((quality >= 0.0) && (quality <= 100.0));
- return ((quality * (POWER_MAX - POWER_MIN)) + POWER_MIN);
+ return (quality * (POWER_MAX - POWER_MIN)) + POWER_MIN;
} /* double wireless_percent_to_power */
static int wireless_read(void) {
if ((fh = fopen(WIRELESS_PROC_FILE, "r")) == NULL) {
char errbuf[1024];
WARNING("wireless: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
devices_found = 0;
/* If no wireless devices are present return an error, so the plugin
* code delays our read function. */
if (devices_found == 0)
- return (-1);
+ return -1;
#endif /* KERNEL_LINUX */
- return (0);
+ return 0;
} /* int wireless_read */
void module_register(void) {
diff --git a/src/write_graphite.c b/src/write_graphite.c
index 3fac9ccac31a3c69144a3007e16c20d89b51f46f..206cdc2d9fc94f66a39fbb884541a76ee011d518 100644 (file)
--- a/src/write_graphite.c
+++ b/src/write_graphite.c
ssize_t status;
if (cb->sock_fd < 0)
- return (-1);
+ return -1;
status = swrite(cb->sock_fd, cb->send_buf, strlen(cb->send_buf));
if (status != 0) {
close(cb->sock_fd);
cb->sock_fd = -1;
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
}
/* NOTE: You must hold cb->send_lock when calling this function! */
now = cdtime();
if ((cb->send_buf_init_time + timeout) > now)
- return (0);
+ return 0;
}
if (cb->send_buf_fill == 0) {
cb->send_buf_init_time = cdtime();
- return (0);
+ return 0;
}
status = wg_send_buffer(cb);
wg_reset_buffer(cb);
- return (status);
+ return status;
}
static int wg_callback_init(struct wg_callback *cb) {
char connerr[1024] = "";
if (cb->sock_fd > 0)
- return (0);
+ return 0;
/* Don't try to reconnect too often. By default, one reconnection attempt
* is made per second. */
now = cdtime();
if ((now - cb->last_connect_time) < WG_MIN_RECONNECT_INTERVAL)
- return (EAGAIN);
+ return EAGAIN;
cb->last_connect_time = now;
struct addrinfo ai_hints = {.ai_family = AF_UNSPEC,
if (status != 0) {
ERROR("write_graphite plugin: getaddrinfo (%s, %s, %s) failed: %s",
cb->node, cb->service, cb->protocol, gai_strerror(status));
- return (-1);
+ return -1;
}
assert(ai_list != NULL);
"write_graphite plugin: Connecting to %s:%s via %s failed. "
"The last error was: %s",
cb->node, cb->service, cb->protocol, connerr);
- return (-1);
+ return -1;
} else {
c_release(LOG_INFO, &cb->init_complaint,
"write_graphite plugin: Successfully connected to %s:%s via %s.",
else
cb->reconnect_interval_reached = 0;
- return (0);
+ return 0;
}
static void wg_callback_free(void *data) {
int status;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
cb = user_data->data;
if (status != 0) {
/* An error message has already been printed. */
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
}
status = wg_flush_nolock(timeout, cb);
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
static int wg_send_message(char const *message, struct wg_callback *cb) {
if (status != 0) {
/* An error message has already been printed. */
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
}
status = wg_flush_nolock(/* timeout = */ 0, cb);
if (status != 0) {
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
}
pthread_mutex_unlock(&cb->send_lock);
- return (0);
+ return 0;
}
static int wg_write_messages(const data_set_t *ds, const value_list_t *vl,
status = format_graphite(buffer, sizeof(buffer), ds, vl, cb->prefix,
cb->postfix, cb->escape_char, cb->format_flags);
if (status != 0) /* error message has been printed already. */
- return (status);
+ return status;
/* Send the message to graphite */
status = wg_send_message(buffer, cb);
if (status != 0) /* error message has been printed already. */
- return (status);
+ return status;
- return (0);
+ return 0;
} /* int wg_write_messages */
static int wg_write(const data_set_t *ds, const value_list_t *vl,
int status;
if (user_data == NULL)
- return (EINVAL);
+ return EINVAL;
cb = user_data->data;
status = wg_write_messages(ds, vl, cb);
- return (status);
+ return status;
}
static int config_set_char(char *dest, oconfig_item_t *ci) {
status = cf_util_get_string_buffer(ci, buffer, sizeof(buffer));
if (status != 0)
- return (status);
+ return status;
if (buffer[0] == 0) {
ERROR("write_graphite plugin: Cannot use an empty string for the "
"\"EscapeCharacter\" option.");
- return (-1);
+ return -1;
}
if (buffer[1] != 0) {
*dest = buffer[0];
- return (0);
+ return 0;
}
static int wg_config_node(oconfig_item_t *ci) {
cb = calloc(1, sizeof(*cb));
if (cb == NULL) {
ERROR("write_graphite plugin: calloc failed.");
- return (-1);
+ return -1;
}
cb->sock_fd = -1;
cb->name = NULL;
status = cf_util_get_string(ci, &cb->name);
if (status != 0) {
wg_callback_free(cb);
- return (status);
+ return status;
}
}
if (status != 0) {
wg_callback_free(cb);
- return (status);
+ return status;
}
/* FIXME: Legacy configuration syntax. */
plugin_register_flush(callback_name, wg_flush, &(user_data_t){.data = cb});
- return (0);
+ return 0;
}
static int wg_config(oconfig_item_t *ci) {
}
}
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/write_http.c b/src/write_http.c
index 097101f4c954c369aa35bdec76f88e4babb3b23d..d5c91d910e8efbd5abadeb8233d24803cca1269d 100644 (file)
--- a/src/write_http.c
+++ b/src/write_http.c
"status %i: %s",
status, cb->curl_errbuf);
}
- return (status);
+ return status;
} /* }}} wh_post_nolock */
static int wh_callback_init(wh_callback_t *cb) /* {{{ */
{
if (cb->curl != NULL)
- return (0);
+ return 0;
cb->curl = curl_easy_init();
if (cb->curl == NULL) {
ERROR("curl plugin: curl_easy_init failed.");
- return (-1);
+ return -1;
}
if (cb->low_speed_limit > 0 && cb->low_speed_time > 0) {
cb->credentials = malloc(credentials_size);
if (cb->credentials == NULL) {
ERROR("curl plugin: malloc failed.");
- return (-1);
+ return -1;
}
ssnprintf(cb->credentials, credentials_size, "%s:%s", cb->user,
wh_reset_buffer(cb);
- return (0);
+ return 0;
} /* }}} int wh_callback_init */
static int wh_flush_nolock(cdtime_t timeout, wh_callback_t *cb) /* {{{ */
now = cdtime();
if ((cb->send_buffer_init_time + timeout) > now)
- return (0);
+ return 0;
}
if (cb->format == WH_FORMAT_COMMAND) {
if (cb->send_buffer_fill == 0) {
cb->send_buffer_init_time = cdtime();
- return (0);
+ return 0;
}
status = wh_post_nolock(cb, cb->send_buffer);
} else if (cb->format == WH_FORMAT_JSON || cb->format == WH_FORMAT_KAIROSDB) {
if (cb->send_buffer_fill <= 2) {
cb->send_buffer_init_time = cdtime();
- return (0);
+ return 0;
}
status = format_json_finalize(cb->send_buffer, &cb->send_buffer_fill,
ERROR("write_http: wh_flush_nolock: "
"format_json_finalize failed.");
wh_reset_buffer(cb);
- return (status);
+ return status;
}
status = wh_post_nolock(cb, cb->send_buffer);
ERROR("write_http: wh_flush_nolock: "
"Unknown format: %i",
cb->format);
- return (-1);
+ return -1;
}
- return (status);
+ return status;
} /* }}} wh_flush_nolock */
static int wh_flush(cdtime_t timeout, /* {{{ */
int status;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
cb = user_data->data;
if (wh_callback_init(cb) != 0) {
ERROR("write_http plugin: wh_callback_init failed.");
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
status = wh_flush_nolock(timeout, cb);
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
} /* }}} int wh_flush */
static void wh_callback_free(void *data) /* {{{ */
status = FORMAT_VL(key, sizeof(key), vl);
if (status != 0) {
ERROR("write_http plugin: error with format_name");
- return (status);
+ return status;
}
escape_string(key, sizeof(key));
if (status != 0) {
ERROR("write_http plugin: error with "
"wh_value_list_to_string");
- return (status);
+ return status;
}
command_len = (size_t)ssnprintf(command, sizeof(command),
ERROR("write_http plugin: Command buffer too small: "
"Need %zu bytes.",
command_len + 1);
- return (-1);
+ return -1;
}
pthread_mutex_lock(&cb->send_lock);
if (wh_callback_init(cb) != 0) {
ERROR("write_http plugin: wh_callback_init failed.");
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
if (command_len >= cb->send_buffer_free) {
status = wh_flush_nolock(/* timeout = */ 0, cb);
if (status != 0) {
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
}
assert(command_len < cb->send_buffer_free);
/* Check if we have enough space for this command. */
pthread_mutex_unlock(&cb->send_lock);
- return (0);
+ return 0;
} /* }}} int wh_write_command */
static int wh_write_json(const data_set_t *ds, const value_list_t *vl, /* {{{ */
@@ -423,7 +423,7 @@ static int wh_write_json(const data_set_t *ds, const value_list_t *vl, /* {{{ */
if (wh_callback_init(cb) != 0) {
ERROR("write_http plugin: wh_callback_init failed.");
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
status =
@@ -434,7 +434,7 @@ static int wh_write_json(const data_set_t *ds, const value_list_t *vl, /* {{{ */
if (status != 0) {
wh_reset_buffer(cb);
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
status =
@@ -443,7 +443,7 @@ static int wh_write_json(const data_set_t *ds, const value_list_t *vl, /* {{{ */
}
if (status != 0) {
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
DEBUG("write_http plugin: <%s> buffer %zu/%zu (%g%%)", cb->location,
@@ -454,7 +454,7 @@ static int wh_write_json(const data_set_t *ds, const value_list_t *vl, /* {{{ */
/* Check if we have enough space for this command. */
pthread_mutex_unlock(&cb->send_lock);
- return (0);
+ return 0;
} /* }}} int wh_write_json */
static int wh_write_kairosdb(const data_set_t *ds,
if (status != 0) {
ERROR("write_http plugin: wh_callback_init failed.");
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
}
if (status != 0) {
wh_reset_buffer(cb);
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
status = format_kairosdb_value_list(
}
if (status != 0) {
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
}
DEBUG("write_http plugin: <%s> buffer %zu/%zu (%g%%)", cb->location,
/* Check if we have enough space for this command. */
pthread_mutex_unlock(&cb->send_lock);
- return (0);
+ return 0;
} /* }}} int wh_write_kairosdb */
static int wh_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
int status;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
cb = user_data->data;
assert(cb->send_metrics);
status = wh_write_command(ds, vl, cb);
break;
}
- return (status);
+ return status;
} /* }}} int wh_write */
static int wh_notify(notification_t const *n, user_data_t *ud) /* {{{ */
int status;
if ((ud == NULL) || (ud->data == NULL))
- return (EINVAL);
+ return EINVAL;
cb = ud->data;
assert(cb->send_notifications);
if (wh_callback_init(cb) != 0) {
ERROR("write_http plugin: wh_callback_init failed.");
pthread_mutex_unlock(&cb->send_lock);
- return (-1);
+ return -1;
}
status = wh_post_nolock(cb, alert);
pthread_mutex_unlock(&cb->send_lock);
- return (status);
+ return status;
} /* }}} int wh_notify */
static int config_set_format(wh_callback_t *cb, /* {{{ */
WARNING("write_http plugin: The `%s' config option "
"needs exactly one string argument.",
ci->key);
- return (-1);
+ return -1;
}
string = ci->values[0].value.string;
cb->format = WH_FORMAT_KAIROSDB;
else {
ERROR("write_http plugin: Invalid format string: %s", string);
- return (-1);
+ return -1;
}
- return (0);
+ return 0;
} /* }}} int config_set_format */
static int wh_config_append_string(const char *name,
struct curl_slist *temp = NULL;
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
WARNING("write_http plugin: `%s' needs exactly one string argument.", name);
- return (-1);
+ return -1;
}
temp = curl_slist_append(*dest, ci->values[0].value.string);
if (temp == NULL)
- return (-1);
+ return -1;
*dest = temp;
- return (0);
+ return 0;
} /* }}} int wh_config_append_string */
static int wh_config_node(oconfig_item_t *ci) /* {{{ */
cb = calloc(1, sizeof(*cb));
if (cb == NULL) {
ERROR("write_http plugin: calloc failed.");
- return (-1);
+ return -1;
}
cb->verify_peer = 1;
cb->verify_host = 1;
if (status != 0) {
wh_callback_free(cb);
- return (status);
+ return status;
}
if (cb->location == NULL) {
ERROR("write_http plugin: no URL defined for instance '%s'", cb->name);
wh_callback_free(cb);
- return (-1);
+ return -1;
}
if (!cb->send_metrics && !cb->send_notifications) {
"are enabled for \"%s\".",
cb->name);
wh_callback_free(cb);
- return (-1);
+ return -1;
}
if (cb->low_speed_limit > 0)
if (cb->send_buffer == NULL) {
ERROR("write_http plugin: malloc(%zu) failed.", cb->send_buffer_size);
wh_callback_free(cb);
- return (-1);
+ return -1;
}
/* Nulls the buffer and sets ..._free and ..._fill. */
wh_reset_buffer(cb);
user_data.free_func = NULL;
}
- return (0);
+ return 0;
} /* }}} int wh_config_node */
static int wh_config(oconfig_item_t *ci) /* {{{ */
}
}
- return (0);
+ return 0;
} /* }}} int wh_config */
static int wh_init(void) /* {{{ */
/* Call this while collectd is still single-threaded to avoid
* initialization issues in libgcrypt. */
curl_global_init(CURL_GLOBAL_SSL);
- return (0);
+ return 0;
} /* }}} int wh_init */
void module_register(void) /* {{{ */
diff --git a/src/write_kafka.c b/src/write_kafka.c
index 306d92ccb2c75888e241faa5f38ace1ba923b990..ca400acbff85348045f76477562bffd4e245cae2 100644 (file)
--- a/src/write_kafka.c
+++ b/src/write_kafka.c
rd_kafka_topic_conf_t *topic_conf;
if (ctx->kafka != NULL && ctx->topic != NULL)
- return (0);
+ return 0;
if (ctx->kafka == NULL) {
if ((conf = rd_kafka_conf_dup(ctx->kafka_conf)) == NULL) {
ERROR("write_kafka plugin: cannot duplicate kafka config");
- return (1);
+ return 1;
}
if ((ctx->kafka = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errbuf,
rd_kafka_topic_name(ctx->topic));
}
- return (0);
+ return 0;
} /* }}} int kafka_handle */
}
if (conf != NULL)
rd_kafka_conf_destroy(conf);
- return (0);
+ return 0;
errout:
if (conf != NULL)
rd_kafka_conf_destroy(conf);
diff --git a/src/write_log.c b/src/write_log.c
index 5ecb1823f7bed41863cc7d53e27f994f5106fe9a..fdc99ef3b67004d4185a8b6b16c3f35f641682c5 100644 (file)
--- a/src/write_log.c
+++ b/src/write_log.c
status = format_graphite(buffer, sizeof(buffer), ds, vl, NULL, NULL, '_', 0);
if (status != 0) /* error message has been printed already. */
- return (status);
+ return status;
INFO("write_log values:\n%s", buffer);
- return (0);
+ return 0;
} /* int wl_write_graphite */
static int wl_write_json(const data_set_t *ds, const value_list_t *vl) {
INFO("write_log values:\n%s", buffer);
- return (0);
+ return 0;
} /* int wl_write_json */
static int wl_write(const data_set_t *ds, const value_list_t *vl,
status = wl_write_json(ds, vl);
}
- return (status);
+ return status;
}
static int wl_config(oconfig_item_t *ci) /* {{{ */
else {
ERROR("write_log plugin: Unknown format `%s' for option `%s'.", str,
child->key);
- return (-EINVAL);
+ return -EINVAL;
}
} else {
ERROR("write_log plugin: Invalid configuration option: `%s'.",
child->key);
- return (-EINVAL);
+ return -EINVAL;
}
}
- return (0);
+ return 0;
} /* }}} int wl_config */
void module_register(void) {
diff --git a/src/write_mongodb.c b/src/write_mongodb.c
index 44181e9387b9363c3518bb9f957579f773a70b4e..3cdc3d1db873847924493a57b0357650bcaa7610 100644 (file)
--- a/src/write_mongodb.c
+++ b/src/write_mongodb.c
node = calloc(1, sizeof(*node));
if (node == NULL)
- return (ENOMEM);
+ return ENOMEM;
mongoc_init();
node->host = NULL;
node->store_rates = 1;
if (status != 0) {
sfree(node);
- return (status);
+ return status;
}
for (int i = 0; i < ci->children_num; i++) {
if (status != 0)
wm_config_free(node);
- return (status);
+ return status;
} /* }}} int wm_config_node */
static int wm_config(oconfig_item_t *ci) /* {{{ */
child->key);
}
- return (0);
+ return 0;
} /* }}} int wm_config */
void module_register(void) {
diff --git a/src/write_prometheus.c b/src/write_prometheus.c
index 14d78bb18dbc469fa39918f8aa801a31c53da7e8..526499849c2f27a5040f8d8b7febc00a107c9494 100644 (file)
--- a/src/write_prometheus.c
+++ b/src/write_prometheus.c
if (m == NULL)
return -1;
- return metric_update(m, vl->values[ds_index], ds->ds[ds_index].type, vl->time,
- vl->interval);
+ return metric_update(m, vl->values[ds_index], ds->ds[ds_index].type,
+ vl->time, vl->interval);
}
/* metric_family_destroy frees the memory used by a metric family. */
diff --git a/src/write_redis.c b/src/write_redis.c
index 9cff34a7287edcbe8a878bfe679f6186772dbc36..f7215b50dbfaaadf38a2f6ff4c9f60d240b0fade 100644 (file)
--- a/src/write_redis.c
+++ b/src/write_redis.c
status = FORMAT_VL(ident, sizeof(ident), vl);
if (status != 0)
- return (status);
+ return status;
ssnprintf(key, sizeof(key), "%s%s",
(node->prefix != NULL) ? node->prefix : REDIS_DEFAULT_PREFIX,
ident);
value_ptr = &value[0];
status = format_values(value_ptr, value_size, ds, vl, node->store_rates);
if (status != 0)
- return (status);
+ return status;
pthread_mutex_lock(&node->lock);
(node->host != NULL) ? node->host : "localhost",
(node->port != 0) ? node->port : 6379);
pthread_mutex_unlock(&node->lock);
- return (-1);
+ return -1;
} else if (node->conn->err) {
ERROR(
"write_redis plugin: Connecting to host \"%s\" (port %i) failed: %s",
(node->host != NULL) ? node->host : "localhost",
(node->port != 0) ? node->port : 6379, node->conn->errstr);
pthread_mutex_unlock(&node->lock);
- return (-1);
+ return -1;
}
rr = redisCommand(node->conn, "SELECT %d", node->database);
pthread_mutex_unlock(&node->lock);
- return (0);
+ return 0;
} /* }}} int wr_write */
static void wr_config_free(void *ptr) /* {{{ */
node = calloc(1, sizeof(*node));
if (node == NULL)
- return (ENOMEM);
+ return ENOMEM;
node->host = NULL;
node->port = 0;
node->timeout.tv_sec = 0;
status = cf_util_get_string_buffer(ci, node->name, sizeof(node->name));
if (status != 0) {
sfree(node);
- return (status);
+ return status;
}
for (int i = 0; i < ci->children_num; i++) {
if (status != 0)
wr_config_free(node);
- return (status);
+ return status;
} /* }}} int wr_config_node */
static int wr_config(oconfig_item_t *ci) /* {{{ */
child->key);
}
- return (0);
+ return 0;
} /* }}} int wr_config */
void module_register(void) {
diff --git a/src/write_riemann.c b/src/write_riemann.c
index a51b4b5857d1e25cc4d50cdb78ff850fcbd850dc..9e07e75119bb0ba5be0e3704ee5b3598c226c620 100644 (file)
--- a/src/write_riemann.c
+++ b/src/write_riemann.c
static int wrr_disconnect(struct riemann_host *host) /* {{{ */
{
if (!host->client)
- return (0);
+ return 0;
riemann_client_free(host->client);
host->client = NULL;
- return (0);
+ return 0;
} /* }}} int wrr_disconnect */
/**
if (msg == NULL) {
ERROR("write_riemann plugin: riemann_message_create_with_events() failed.");
riemann_event_free(event);
- return (NULL);
+ return NULL;
}
DEBUG("write_riemann plugin: Successfully created message for notification: "
"host = \"%s\", service = \"%s\", state = \"%s\"",
event->host, event->service, event->state);
- return (msg);
+ return msg;
} /* }}} riemann_message_t *wrr_notification_to_message */
static riemann_event_t *
event = riemann_event_new();
if (event == NULL) {
ERROR("write_riemann plugin: riemann_event_new() failed.");
- return (NULL);
+ return NULL;
}
format_name(name_buffer, sizeof(name_buffer),
DEBUG("write_riemann plugin: Successfully created message for metric: "
"host = \"%s\", service = \"%s\"",
event->host, event->service);
- return (event);
+ return event;
} /* }}} riemann_event_t *wrr_value_to_event */
static riemann_message_t *
msg = riemann_message_new();
if (msg == NULL) {
ERROR("write_riemann plugin: riemann_message_new failed.");
- return (NULL);
+ return NULL;
}
if (host->store_rates) {
if (rates == NULL) {
ERROR("write_riemann plugin: uc_get_rate failed.");
riemann_message_free(msg);
- return (NULL);
+ return NULL;
}
}
if (event == NULL) {
riemann_message_free(msg);
sfree(rates);
- return (NULL);
+ return NULL;
}
riemann_message_append_events(msg, event, NULL);
}
sfree(rates);
- return (msg);
+ return msg;
} /* }}} riemann_message_t *wrr_value_list_to_message */
/*
int status;
if (user_data == NULL)
- return (-EINVAL);
+ return -EINVAL;
host = user_data->data;
pthread_mutex_lock(&host->lock);
*/
msg = wrr_notification_to_message(host, n);
if (msg == NULL)
- return (-1);
+ return -1;
status = wrr_send(host, msg);
if (status != 0)
"write_riemann plugin: riemann_client_send succeeded");
riemann_message_free(msg);
- return (status);
+ return status;
} /* }}} int wrr_notification */
static int wrr_write(const data_set_t *ds, /* {{{ */
} else {
msg = wrr_value_list_to_message(host, ds, vl, statuses);
if (msg == NULL)
- return (-1);
+ return -1;
status = wrr_send(host, msg);
* holding a reference. */
pthread_mutex_unlock(&host->lock);
wrr_free(host);
- return (-1);
+ return -1;
}
host->reference_count--;
if (child->values_num != 2) {
WARNING("riemann attributes need both a key and a value.");
- return (-1);
+ return -1;
}
if (child->values[0].type != OCONFIG_TYPE_STRING ||
child->values[1].type != OCONFIG_TYPE_STRING) {
WARNING("riemann attribute needs string arguments.");
- return (-1);
+ return -1;
}
if ((key = strdup(child->values[0].value.string)) == NULL) {
WARNING("cannot allocate memory for attribute key.");
- return (-1);
+ return -1;
}
if ((val = strdup(child->values[1].value.string)) == NULL) {
WARNING("cannot allocate memory for attribute value.");
sfree(key);
- return (-1);
+ return -1;
}
strarray_add(&riemann_attrs, &riemann_attrs_num, key);
strarray_add(&riemann_attrs, &riemann_attrs_num, val);
child->key);
}
}
- return (0);
+ return 0;
} /* }}} int wrr_config */
void module_register(void) {
index 8f6b4beda4b92685e1743d2d32d804a6fe82303d..35f3814a5f26b8c4d64bf47867f658fce80ac05b 100644 (file)
if (ds != NULL) {
ds_name = ds->ds[ds_index].name;
if ((th->data_source[0] != 0) && (strcmp(ds_name, th->data_source) != 0))
- return (STATE_OKAY);
+ return STATE_OKAY;
}
if ((th->flags & UT_FLAG_INVERT) != 0) {
((th->failure_min + th->hysteresis) < values[ds_index])) ||
(!isnan(th->failure_max) &&
((th->failure_max - th->hysteresis) > values[ds_index])))
- return (STATE_OKAY);
+ return STATE_OKAY;
else
is_failure++;
case STATE_WARNING:
((th->warning_min + th->hysteresis) < values[ds_index])) ||
(!isnan(th->warning_max) &&
((th->warning_max - th->hysteresis) > values[ds_index])))
- return (STATE_OKAY);
+ return STATE_OKAY;
else
is_warning++;
}
}
if (is_failure != 0)
- return (STATE_ERROR);
+ return STATE_ERROR;
if (is_warning != 0)
- return (STATE_WARNING);
+ return STATE_WARNING;
- return (STATE_OKAY);
+ return STATE_OKAY;
} /* }}} int ut_check_one_data_source */
/*
}
} /* for (ds->ds_num) */
- return (ret);
+ return ret;
} /* }}} int ut_check_one_threshold */
/*
@@ -200,20 +200,20 @@ int write_riemann_threshold_check(const data_set_t *ds, const value_list_t *vl,
th = threshold_search(vl);
pthread_mutex_unlock(&threshold_lock);
if (th == NULL)
- return (0);
+ return 0;
DEBUG("ut_check_threshold: Found matching threshold(s)");
values = uc_get_rate(ds, vl);
if (values == NULL)
- return (0);
+ return 0;
while (th != NULL) {
status = ut_check_one_threshold(ds, vl, th, values, statuses);
if (status < 0) {
ERROR("ut_check_threshold: ut_check_one_threshold failed.");
sfree(values);
- return (-1);
+ return -1;
}
th = th->next;
sfree(values);
- return (0);
+ return 0;
} /* }}} int ut_check_threshold */
diff --git a/src/write_sensu.c b/src/write_sensu.c
index 6e6517bdf845cdd836fd76ae36c5f86ba21a7e68..56acb638b016abceb679d9ba56e0ae1abbb2d6c3 100644 (file)
--- a/src/write_sensu.c
+++ b/src/write_sensu.c
do { \
size_t l = strlen(str); \
if (l >= buffer_size) \
- return (ENOBUFS); \
+ return ENOBUFS; \
memcpy(buffer, (str), l); \
buffer += l; \
buffer_size -= l; \
buffer[0] = 0;
#undef APPEND
- return (0);
+ return 0;
} /* int sensu_format_name2 */
static void in_place_replace_sensu_name_reserved(char *orig_name) /* {{{ */
diff --git a/src/write_tsdb.c b/src/write_tsdb.c
index 99c84278906d1a9fb8b52c9a8354bb69c245bb62..1a1cd648eb6d0b8bb4a6324fb259bd1b5b2c2f79 100644 (file)
--- a/src/write_tsdb.c
+++ b/src/write_tsdb.c
if ((cb->ai_last_update + resolve_interval + cb->next_random_ttl) >= now) {
DEBUG("write_tsdb plugin: too many getaddrinfo(%s, %s) failures", node,
service);
- return (-1);
+ return -1;
}
cb->ai_last_update = now;
cb->next_random_ttl = new_random_ttl();
diff --git a/src/xencpu.c b/src/xencpu.c
index 01904b284c5c9af50b61c076c38a6afcc8422264..bf1786477eeebf2342025034fd92560878953002 100644 (file)
--- a/src/xencpu.c
+++ b/src/xencpu.c
xc_handle = xc_interface_open(XC_INTERFACE_INIT_ARGS);
if (!xc_handle) {
ERROR("xencpu: xc_interface_open() failed");
- return (-1);
+ return -1;
}
xc_physinfo_t *physinfo;
if (physinfo == NULL) {
ERROR("xencpu plugin: calloc() for physinfo failed.");
xc_interface_close(xc_handle);
- return (ENOMEM);
+ return ENOMEM;
}
if (xc_physinfo(xc_handle, physinfo) < 0) {
ERROR("xencpu plugin: xc_physinfo() failed");
xc_interface_close(xc_handle);
free(physinfo);
- return (-1);
+ return -1;
}
num_cpus = physinfo->nr_cpus;
if (cpu_info == NULL) {
ERROR("xencpu plugin: calloc() for num_cpus failed.");
xc_interface_close(xc_handle);
- return (ENOMEM);
+ return ENOMEM;
}
cpu_states = calloc(num_cpus, sizeof(value_to_rate_state_t));
ERROR("xencpu plugin: calloc() for cpu_states failed.");
xc_interface_close(xc_handle);
free(cpu_info);
- return (ENOMEM);
+ return ENOMEM;
}
- return (0);
+ return 0;
} /* static int xencpu_init */
static int xencpu_shutdown(void) {
if (rc < 0) {
ERROR("xencpu: xc_getcpuinfo() Failed: %d %s\n", rc,
xc_strerror(xc_handle, errno));
- return (-1);
+ return -1;
}
int status;
}
}
- return (0);
+ return 0;
} /* static int xencpu_read */
void module_register(void) {
diff --git a/src/xmms.c b/src/xmms.c
index b06434d4deaeddd8874676c675c2153e23556e1b..3e3a3c3c50b8fb45cc5e6f901a2d13f059c0966b 100644 (file)
--- a/src/xmms.c
+++ b/src/xmms.c
gint nch;
if (!xmms_remote_is_running(xmms_session))
- return (0);
+ return 0;
xmms_remote_get_info(xmms_session, &rate, &freq, &nch);
if ((freq == 0) || (nch == 0))
- return (-1);
+ return -1;
cxmms_submit("bitrate", rate);
cxmms_submit("frequency", freq);
- return (0);
+ return 0;
} /* int read */
void module_register(void) {
diff --git a/src/zfs_arc.c b/src/zfs_arc.c
index aff02b62ccc390a6d000f355063f39f59c701bc2..cf858f8f55867c44f2b82b083187d982748600fb 100644 (file)
--- a/src/zfs_arc.c
+++ b/src/zfs_arc.c
e = llist_search(ksp, key);
if (e == NULL) {
- return (-1);
+ return -1;
}
v = e->value;
- return ((long long)v->derive);
+ return (long long)v->derive;
}
static void free_zfs_values(kstat_t *ksp) {
static long long get_zfs_value(kstat_t *ksp, char *name) {
- return (get_kstat_value(ksp, name));
+ return get_kstat_value(ksp, name);
}
#elif defined(KERNEL_FREEBSD)
#include <sys/sysctl.h>
rv = sysctlbyname(buffer, (void *)&value, &valuelen,
/* new value = */ NULL, /* new length = */ (size_t)0);
if (rv == 0)
- return (value);
+ return value;
- return (-1);
+ return -1;
}
#endif
long long tmp = get_zfs_value(ksp, (char *)kstat_value);
if (tmp == -1LL) {
DEBUG("zfs_arc plugin: Reading kstat value \"%s\" failed.", kstat_value);
- return (-1);
+ return -1;
}
za_submit(type, type_instance, &(value_t){.derive = (derive_t)tmp},
/* values_num = */ 1);
- return (0);
+ return 0;
}
static int za_read_gauge(kstat_t *ksp, const char *kstat_value,
long long tmp = get_zfs_value(ksp, (char *)kstat_value);
if (tmp == -1LL) {
DEBUG("zfs_arc plugin: Reading kstat value \"%s\" failed.", kstat_value);
- return (-1);
+ return -1;
}
za_submit(type, type_instance, &(value_t){.gauge = (gauge_t)tmp},
/* values_num = */ 1);
- return (0);
+ return 0;
}
static void za_submit_ratio(const char *type_instance, gauge_t hits,
char errbuf[1024];
ERROR("zfs_arc plugin: Opening \"%s\" failed: %s", ZOL_ARCSTATS_FILE,
sstrerror(errno, errbuf, sizeof(errbuf)));
- return (-1);
+ return -1;
}
ksp = llist_create();
if (ksp == NULL) {
ERROR("zfs_arc plugin: `llist_create' failed.");
fclose(fh);
- return (-1);
+ return -1;
}
// Ignore the first two lines because they contain information about
if (fgets(buffer, sizeof(buffer), fh) == NULL) {
ERROR("zfs_arc plugin: \"%s\" does not contain a single line.", ZOL_ARCSTATS_FILE);
fclose(fh);
- return (-1);
+ return -1;
}
if (fgets(buffer, sizeof(buffer), fh) == NULL) {
ERROR("zfs_arc plugin: \"%s\" does not contain at least two lines.", ZOL_ARCSTATS_FILE);
fclose(fh);
- return (-1);
+ return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
get_kstat(&ksp, "zfs", 0, "arcstats");
if (ksp == NULL) {
ERROR("zfs_arc plugin: Cannot find zfs:0:arcstats kstat.");
- return (-1);
+ return -1;
}
#endif
free_zfs_values(ksp);
#endif
- return (0);
+ return 0;
} /* int za_read */
static int za_init(void) /* {{{ */
* went fine. */
if (kc == NULL) {
ERROR("zfs_arc plugin: kstat chain control structure not available.");
- return (-1);
+ return -1;
}
#endif
- return (0);
+ return 0;
} /* }}} int za_init */
void module_register(void) {
diff --git a/src/zone.c b/src/zone.c
index 5b7bd00fcc70319bd1480206fcafd64c1a4371c0..3cd05347b2a1e9cd21b86c6762d61804dbc926b0 100644 (file)
--- a/src/zone.c
+++ b/src/zone.c
static int zone_compare(const void *a, const void *b) {
if (*(const zoneid_t *)a == *(const zoneid_t *)b)
- return (0);
+ return 0;
if (*(const zoneid_t *)a < *(const zoneid_t *)b)
- return (-1);
- return (1);
+ return -1;
+ return 1;
}
static int zone_read_procfile(char const *pidstr, char const *name, void *buf,
char procfile[MAX_PROCFS_PATH];
(void)snprintf(procfile, sizeof(procfile), "/proc/%s/%s", pidstr, name);
if ((fd = open(procfile, O_RDONLY)) == -1) {
- return (1);
+ return 1;
}
if (sread(fd, buf, bufsize) != 0) {
ERROR("zone plugin: Reading \"%s\" failed: %s", procfile,
sstrerror(errno, errbuf, sizeof(errbuf)));
close(fd);
- return (1);
+ return 1;
}
close(fd);
- return (0);
+ return 0;
}
static int zone_submit_value(char *zone, gauge_t value) {
sstrncpy(vl.type, "percent", sizeof(vl.type));
sstrncpy(vl.type_instance, zone, sizeof(vl.type_instance));
- return (plugin_dispatch_values(&vl));
+ return plugin_dispatch_values(&vl);
}
static zone_stats_t *zone_find_stats(c_avl_tree_t *tree, zoneid_t zoneid) {
if (c_avl_get(tree, (void **)&zoneid, (void **)&ret)) {
if (!(ret = malloc(sizeof(*ret)))) {
WARNING("zone plugin: no memory");
- return (NULL);
+ return NULL;
}
if (!(key = malloc(sizeof(*key)))) {
WARNING("zone plugin: no memory");
free(ret);
- return (NULL);
+ return NULL;
}
*key = zoneid;
if (c_avl_insert(tree, key, ret)) {
WARNING("zone plugin: error inserting into tree");
- return (NULL);
+ return NULL;
}
}
- return (ret);
+ return ret;
}
static void zone_submit_values(c_avl_tree_t *tree) {
if (!(tree = c_avl_create(zone_compare))) {
WARNING("zone plugin: Failed to create tree");
- return (NULL);
+ return NULL;
}
rewinddir(procdir);
stats->pctmem += psinfo.pr_pctmem;
}
}
- return (tree);
+ return tree;
}
static int zone_read(void) {
if ((procdir = opendir("/proc")) == NULL) {
ERROR("zone plugin: cannot open /proc directory\n");
- return (-1);
+ return -1;
}
tree = zone_scandir(procdir);
closedir(procdir);
if (tree == NULL) {
- return (-1);
+ return -1;
}
zone_submit_values(tree); /* this also frees tree */
- return (0);
+ return 0;
}
void module_register(void) {
diff --git a/src/zookeeper.c b/src/zookeeper.c
index a42b04c83f1ad06a11cff37af69d8b6b4efa1017..0b2507d88a47b4d2f11e0e32534a56eadf454bb1 100644 (file)
--- a/src/zookeeper.c
+++ b/src/zookeeper.c
INFO("getaddrinfo failed: %s",
(status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
: gai_strerror(status));
- return (-1);
+ return -1;
}
for (struct addrinfo *ai = ai_list; ai != NULL; ai = ai->ai_next) {
}
freeaddrinfo(ai_list);
- return (sk);
+ return sk;
} /* int zookeeper_connect */
static int zookeeper_query(char *buffer, size_t buffer_size) {
sk = zookeeper_connect();
if (sk < 0) {
ERROR("zookeeper: Could not connect to daemon");
- return (-1);
+ return -1;
}
status = (int)swrite(sk, "mntr\r\n", strlen("mntr\r\n"));
ERROR("zookeeper: write(2) failed: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(sk);
- return (-1);
+ return -1;
}
memset(buffer, 0, buffer_size);
ERROR("zookeeper: Error reading from socket: %s",
sstrerror(errno, errbuf, sizeof(errbuf)));
close(sk);
- return (-1);
+ return -1;
}
buffer_fill += (size_t)status;
}
close(sk);
- return (status);
+ return status;
} /* int zookeeper_query */
static int zookeeper_read(void) {
char *fields[2];
if (zookeeper_query(buf, sizeof(buf)) < 0) {
- return (-1);
+ return -1;
}
ptr = buf;
}
}
- return (0);
+ return 0;
} /* zookeeper_read */
void module_register(void) {