sstrncpy(inst->ident.plugin_instance, AGG_FUNC_PLACEHOLDER,
sizeof(inst->ident.plugin_instance));
else if (strcmp("", tmp_plugin) != 0)
- snprintf(inst->ident.plugin_instance, sizeof(inst->ident.plugin_instance),
+ ssnprintf(inst->ident.plugin_instance, sizeof(inst->ident.plugin_instance),
"%s-%s", tmp_plugin, AGG_FUNC_PLACEHOLDER);
else if (strcmp("", tmp_plugin_instance) != 0)
- snprintf(inst->ident.plugin_instance, sizeof(inst->ident.plugin_instance),
+ ssnprintf(inst->ident.plugin_instance, sizeof(inst->ident.plugin_instance),
"%s-%s", tmp_plugin_instance, AGG_FUNC_PLACEHOLDER);
else
- snprintf(inst->ident.plugin_instance, sizeof(inst->ident.plugin_instance),
+ ssnprintf(inst->ident.plugin_instance, sizeof(inst->ident.plugin_instance),
"%s-%s-%s", tmp_plugin, tmp_plugin_instance,
AGG_FUNC_PLACEHOLDER);
}
if (r.reply.id == AMQP_CONNECTION_CLOSE_METHOD) {
amqp_connection_close_t *m = r.reply.decoded;
char *tmp = camqp_bytes_cstring(&m->reply_text);
- snprintf(buffer, buffer_size, "Server connection error %d: %s",
+ ssnprintf(buffer, buffer_size, "Server connection error %d: %s",
m->reply_code, tmp);
sfree(tmp);
} else if (r.reply.id == AMQP_CHANNEL_CLOSE_METHOD) {
amqp_channel_close_t *m = r.reply.decoded;
char *tmp = camqp_bytes_cstring(&m->reply_text);
- snprintf(buffer, buffer_size, "Server channel error %d: %s",
+ ssnprintf(buffer, buffer_size, "Server channel error %d: %s",
m->reply_code, tmp);
sfree(tmp);
} else {
- snprintf(buffer, buffer_size, "Server error method %#" PRIx32,
+ ssnprintf(buffer, buffer_size, "Server error method %#" PRIx32,
r.reply.id);
}
break;
default:
- snprintf(buffer, buffer_size, "Unknown reply type %i", (int)r.reply_type);
+ ssnprintf(buffer, buffer_size, "Unknown reply type %i", (int)r.reply_type);
}
return buffer;
if (conf->routing_key != NULL) {
sstrncpy(routing_key, conf->routing_key, sizeof(routing_key));
} else {
- snprintf(routing_key, sizeof(routing_key), "collectd/%s/%s/%s/%s/%s",
+ ssnprintf(routing_key, sizeof(routing_key), "collectd/%s/%s/%s/%s/%s",
vl->host, vl->plugin, vl->plugin_instance, vl->type,
vl->type_instance);
if (publish) {
char cbname[128];
- snprintf(cbname, sizeof(cbname), "amqp/%s", conf->name);
+ ssnprintf(cbname, sizeof(cbname), "amqp/%s", conf->name);
status =
plugin_register_write(cbname, camqp_write,
return status;
} else {
char tpname[DATA_MAX_NAME_LEN];
- status = snprintf(tpname, sizeof(tpname), "amqp1/%s", instance->name);
+ status = ssnprintf(tpname, sizeof(tpname), "amqp1/%s", instance->name);
if ((status < 0) || (size_t)status >= sizeof(tpname)) {
ERROR("amqp1 plugin: Instance name would have been truncated.");
return -1;
}
- status = snprintf(instance->send_to, sizeof(instance->send_to), "/%s/%s",
+ status = ssnprintf(instance->send_to, sizeof(instance->send_to), "/%s/%s",
transport->address, instance->name);
if ((status < 0) || (size_t)status >= sizeof(instance->send_to)) {
ERROR("amqp1 plugin: send_to address would have been truncated.");
if (value_array[i] == AQ5_FLOAT_UNDEF)
continue;
- snprintf(type_instance, sizeof(type_instance), "%s%d", type_instance_prefix,
+ ssnprintf(type_instance, sizeof(type_instance), "%s%d", type_instance_prefix,
i + 1);
aquaero_submit(type, type_instance, value_array[i]);
}
(aq_data.fan_vrm_temp[i] != AQ5_FLOAT_UNDEF))
continue;
- snprintf(type_instance, sizeof(type_instance), "fan%d", i + 1);
+ ssnprintf(type_instance, sizeof(type_instance), "fan%d", i + 1);
aquaero_submit("fanspeed", type_instance, aq_data.fan_rpm[i]);
aquaero_submit("percent", type_instance, aq_data.fan_duty[i]);
/* Report the voltage reglator module (VRM) temperature with a
* different type instance. */
- snprintf(type_instance, sizeof(type_instance), "fan%d-vrm", i + 1);
+ ssnprintf(type_instance, sizeof(type_instance), "fan%d-vrm", i + 1);
aquaero_submit("temperature", type_instance, aq_data.fan_vrm_temp[i]);
}
static char credentials[1024];
int status;
- status = snprintf(credentials, sizeof(credentials), "%s:%s", user,
+ status = ssnprintf(credentials, sizeof(credentials), "%s:%s", user,
(pass == NULL) ? "" : pass);
if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
ERROR("ascent plugin: ascent_init: Returning an error because the "
return err;
}
address.sun_family = AF_UNIX;
- snprintf(address.sun_path, sizeof(address.sun_path), "%s", io->d->asok_path);
+ ssnprintf(address.sun_path, sizeof(address.sun_path), "%s", io->d->asok_path);
RETRY_ON_EINTR(err, connect(fd, (struct sockaddr *)&address,
sizeof(struct sockaddr_un)));
if (err < 0) {
return -EDOM;
case CSTATE_WRITE_REQUEST: {
char cmd[32];
- snprintf(cmd, sizeof(cmd), "%s%d%s", "{ \"prefix\": \"", io->request_type,
+ ssnprintf(cmd, sizeof(cmd), "%s%d%s", "{ \"prefix\": \"", io->request_type,
"\" }\n");
size_t cmd_len = strlen(cmd);
RETRY_ON_EINTR(
#include <stdio.h>
#include <stdlib.h>
+#include <stdarg.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
extern char *optarg;
extern int optind;
+/* ssnprintf returns zero on success, one if truncation occurred
+ and a negative integer onerror. */
+static int _ssnprintf(char *str, size_t sz, const char *format, ...) {
+ va_list ap;
+ va_start(ap, format);
+
+ int ret = vsnprintf(str, sz, format, ap);
+
+ va_end(ap);
+
+ if (ret < 0) {
+ return ret;
+ }
+ return (size_t)ret >= sz;
+} /* int _ssnprintf */
+
__attribute__((noreturn)) static void exit_usage(const char *name, int status) {
fprintf(
(status == 0) ? stdout : stderr,
}
hostname[sizeof(hostname) - 1] = '\0';
- snprintf(ident_str, sizeof(ident_str), "%s/%s", hostname, value);
+ _ssnprintf(ident_str, sizeof(ident_str), "%s/%s", hostname, value);
ident_str[sizeof(ident_str) - 1] = '\0';
} else {
strncpy(ident_str, value, sizeof(ident_str));
switch (opt) {
case 's':
- snprintf(address, sizeof(address), "unix:%s", optarg);
+ _ssnprintf(address, sizeof(address), "unix:%s", optarg);
address[sizeof(address) - 1] = '\0';
break;
case 'h':
return global_option_set(ci->key, ci->values[0].value.string, 0);
else if (ci->values[0].type == OCONFIG_TYPE_NUMBER) {
char tmp[128];
- snprintf(tmp, sizeof(tmp), "%lf", ci->values[0].value.number);
+ ssnprintf(tmp, sizeof(tmp), "%lf", ci->values[0].value.number);
return global_option_set(ci->key, tmp, 0);
} else if (ci->values[0].type == OCONFIG_TYPE_BOOLEAN) {
if (ci->values[0].value.boolean)
if (ci->values[i].type == OCONFIG_TYPE_STRING)
status =
- snprintf(buffer_ptr, buffer_free, " %s", ci->values[i].value.string);
+ ssnprintf(buffer_ptr, buffer_free, " %s", ci->values[i].value.string);
else if (ci->values[i].type == OCONFIG_TYPE_NUMBER)
status =
- snprintf(buffer_ptr, buffer_free, " %lf", ci->values[i].value.number);
+ ssnprintf(buffer_ptr, buffer_free, " %lf", ci->values[i].value.number);
else if (ci->values[i].type == OCONFIG_TYPE_BOOLEAN)
- status = snprintf(buffer_ptr, buffer_free, " %s",
+ status = ssnprintf(buffer_ptr, buffer_free, " %s",
ci->values[i].value.boolean ? "true" : "false");
if ((status < 0) || (status >= buffer_free))
if ((de->d_name[0] == '.') || (de->d_name[0] == 0))
continue;
- status = snprintf(name, sizeof(name), "%s/%s", dir, de->d_name);
+ status = ssnprintf(name, sizeof(name), "%s/%s", dir, de->d_name);
if ((status < 0) || ((size_t)status >= sizeof(name))) {
ERROR("configfile: Not including `%s/%s' because its"
" name is too long.",
P_ERROR("cf_util_get_service: Out of memory.");
return -1;
}
- snprintf(service, 6, "%i", port);
+ ssnprintf(service, 6, "%i", port);
sfree(*ret_string);
*ret_string = service;
sstrncpy(disk_name, props_disk_name_bsd, sizeof(disk_name));
else {
ERROR("disk plugin: can't find bsd disk name.");
- snprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major, disk_minor);
+ ssnprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major, disk_minor);
}
} else
- snprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major, disk_minor);
+ ssnprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major, disk_minor);
DEBUG("disk plugin: disk_name = \"%s\"", disk_name);
char dev_name[DATA_MAX_NAME_LEN];
if (ec->config.link_status.port_name[i][0] != 0) {
- snprintf(dev_name, sizeof(dev_name), "%s",
+ ssnprintf(dev_name, sizeof(dev_name), "%s",
ec->config.link_status.port_name[i]);
} else {
- snprintf(dev_name, sizeof(dev_name), "port.%d", i);
+ ssnprintf(dev_name, sizeof(dev_name), "port.%d", i);
}
if (ec->config.link_status.notify) {
int sev = ec->link_info[i].link_status ? NOTIF_OKAY : NOTIF_WARNING;
char msg[DATA_MAX_NAME_LEN];
- snprintf(msg, sizeof(msg), "Link Status: %s",
+ ssnprintf(msg, sizeof(msg), "Link Status: %s",
ec->link_info[i].link_status ? "UP" : "DOWN");
dpdk_events_notification_dispatch(sev, dev_name,
ec->link_info[i].read_time, msg);
}
char core_name[DATA_MAX_NAME_LEN];
- snprintf(core_name, sizeof(core_name), "lcore%u", i);
+ ssnprintf(core_name, sizeof(core_name), "lcore%u", i);
if (!ec->config.keep_alive.send_updated ||
(ec->core_info[i].lcore_state !=
switch (ec->config.keep_alive.shm->core_state[i]) {
case RTE_KA_STATE_ALIVE:
sev = NOTIF_OKAY;
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: ALIVE", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: ALIVE", i);
break;
case RTE_KA_STATE_MISSING:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: MISSING", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: MISSING", i);
sev = NOTIF_WARNING;
break;
case RTE_KA_STATE_DEAD:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DEAD", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DEAD", i);
sev = NOTIF_FAILURE;
break;
case RTE_KA_STATE_UNUSED:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNUSED", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNUSED", i);
sev = NOTIF_OKAY;
break;
case RTE_KA_STATE_GONE:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: GONE", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: GONE", i);
sev = NOTIF_FAILURE;
break;
case RTE_KA_STATE_DOZING:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DOZING", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DOZING", i);
sev = NOTIF_OKAY;
break;
case RTE_KA_STATE_SLEEP:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: SLEEP", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: SLEEP", i);
sev = NOTIF_OKAY;
break;
default:
- snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNKNOWN", i);
+ ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNKNOWN", i);
sev = NOTIF_FAILURE;
}
char dev_name[64];
if (ctx->config.port_name[i][0] != 0) {
- snprintf(dev_name, sizeof(dev_name), "%s", ctx->config.port_name[i]);
+ ssnprintf(dev_name, sizeof(dev_name), "%s", ctx->config.port_name[i]);
} else {
- snprintf(dev_name, sizeof(dev_name), "port.%d", i);
+ ssnprintf(dev_name, sizeof(dev_name), "port.%d", i);
}
DEBUG(" === Dispatch stats for port %d (name=%s; stats_count=%d)", i,
if (staging_tree == NULL)
return NULL;
- snprintf(key, sizeof(key), "%s/%s/%s", host, type,
+ ssnprintf(key, sizeof(key), "%s/%s/%s", host, type,
(type_instance != NULL) ? type_instance : "");
se = NULL;
vl.values_len = 1;
sstrncpy(vl.plugin, RDT_PLUGIN, sizeof(vl.plugin));
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s", cgroup);
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s", cgroup);
sstrncpy(vl.type, type, sizeof(vl.type));
if (type_instance)
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
vl.values_len = 1;
sstrncpy(vl.plugin, RDT_PLUGIN, sizeof(vl.plugin));
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s", cgroup);
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s", cgroup);
sstrncpy(vl.type, type, sizeof(vl.type));
if (type_instance)
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
memset(cores, 0, sizeof(cores));
for (size_t j = 0; j < cgroup->num_cores; j++) {
- snprintf(cores + strlen(cores), sizeof(cores) - strlen(cores) - 1, " %d",
+ ssnprintf(cores + strlen(cores), sizeof(cores) - strlen(cores) - 1, " %d",
cgroup->cores[j]);
}
for (size_t i = 0; i < g_rdt->num_ngroups; i++) {
memset(names, 0, sizeof(names));
for (size_t j = 0; j < g_rdt->ngroups[i].num_names; j++)
- snprintf(names + strlen(names), sizeof(names) - strlen(names) - 1, " %s",
+ ssnprintf(names + strlen(names), sizeof(names) - strlen(names) - 1, " %s",
g_rdt->ngroups[i].names[j]);
DEBUG(RDT_PLUGIN ": group[%d]:", (int)i);
for (size_t j = 0; j < g_rdt->ngroups[i].num_names; ++j) {
pids_list_t *list = g_rdt->ngroups[i].proc_pids[j]->curr;
for (size_t k = 0; k < list->size; k++)
- snprintf(pids + strlen(pids), sizeof(pids) - strlen(pids) - 1, " %u",
+ ssnprintf(pids + strlen(pids), sizeof(pids) - strlen(pids) - 1, " %u",
list->pids[k]);
}
DEBUG(RDT_PLUGIN ": [%s] %s", g_rdt->ngroups[i].desc, pids);
cgroup->num_cores = 1;
cgroup->cores[0] = i;
- snprintf(desc, sizeof(desc), "%d", g_rdt->pqos_cpu->cores[i].lcore);
+ ssnprintf(desc, sizeof(desc), "%d", g_rdt->pqos_cpu->cores[i].lcore);
cgroup->desc = strdup(desc);
if (cgroup->desc == NULL) {
ERROR(RDT_PLUGIN ": Error allocating core group description");
continue;
if (unique_name)
- snprintf(iname, sizeof(iname), "%s_%d_%s", ksp[i]->ks_module,
+ ssnprintf(iname, sizeof(iname), "%s_%d_%s", ksp[i]->ks_module,
ksp[i]->ks_instance, ksp[i]->ks_name);
else
sstrncpy(iname, ksp[i]->ks_name, sizeof(iname));
}
if (errbuf[0] == 0) {
- snprintf(errbuf, sizeof(errbuf), "Unknown error %#x", status);
+ ssnprintf(errbuf, sizeof(errbuf), "Unknown error %#x", status);
}
errbuf[sizeof(errbuf) - 1] = '\0';
sstrncpy(n.type_instance, list_item->type_instance,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- snprintf(n.message, sizeof(n.message), "sensor %s not present",
+ ssnprintf(n.message, sizeof(n.message), "sensor %s not present",
list_item->sensor_name);
plugin_dispatch_notification(&n);
sstrncpy(n.type_instance, list_item->type_instance,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- snprintf(n.message, sizeof(n.message), "sensor %s present",
+ ssnprintf(n.message, sizeof(n.message), "sensor %s present",
list_item->sensor_name);
plugin_dispatch_notification(&n);
temp[sizeof(temp) - 1] = '\0';
if (entity_id_string != NULL && strlen(temp))
- snprintf(sensor_name, sizeof(sensor_name), "%s %s", temp, entity_id_string);
+ ssnprintf(sensor_name, sizeof(sensor_name), "%s %s", temp, entity_id_string);
else if (entity_id_string != NULL)
sstrncpy(sensor_name, entity_id_string, sizeof(sensor_name));
else
sensor_id_ptr = strstr(temp, "(");
if (sensor_id_ptr != NULL) {
/* `sensor_id_ptr' now points to "(123)". */
- snprintf(sensor_name, sizeof(sensor_name), "%s %s", sensor_name_ptr,
+ ssnprintf(sensor_name, sizeof(sensor_name), "%s %s", sensor_name_ptr,
sensor_id_ptr);
}
/* else: don't touch sensor_name. */
/* if sensor provides the percentage value, use "percent" collectd type
and add the `percent` to the type instance of the reported value */
if (ipmi_sensor_get_percentage(sensor)) {
- snprintf(list_item->type_instance, sizeof(list_item->type_instance),
+ ssnprintf(list_item->type_instance, sizeof(list_item->type_instance),
"percent-%s", sensor_name_ptr);
type = "percent";
} else {
sstrncpy(n.type_instance, list_item->type_instance,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- snprintf(n.message, sizeof(n.message), "sensor %s added",
+ ssnprintf(n.message, sizeof(n.message), "sensor %s added",
list_item->sensor_name);
plugin_dispatch_notification(&n);
sstrncpy(n.type_instance, list_item->type_instance,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- snprintf(n.message, sizeof(n.message), "sensor %s removed",
+ ssnprintf(n.message, sizeof(n.message), "sensor %s removed",
list_item->sensor_name);
plugin_dispatch_notification(&n);
ipmi_get_reading_name(event_type, sensor_type, offset);
sensor_get_name(sensor, n.type_instance, sizeof(n.type_instance));
if (value_present != IPMI_NO_VALUES_PRESENT)
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"sensor %s received event: %s, value is %f", n.type_instance,
event_state, value);
else
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"sensor %s received event: %s, value not provided",
n.type_instance, event_state);
/* both values present, so fall-through to add raw value too */
case IPMI_RAW_VALUE_PRESENT: {
char buf[DATA_MAX_NAME_LEN] = {0};
- snprintf(buf, sizeof(buf), "0x%2.2x", raw_value);
+ ssnprintf(buf, sizeof(buf), "0x%2.2x", raw_value);
plugin_notification_meta_add_string(&n, "raw", buf);
} break;
default:
const char *event_state =
ipmi_get_reading_name(event_type, sensor_type, offset);
sensor_get_name(sensor, n.type_instance, sizeof(n.type_instance));
- snprintf(n.message, sizeof(n.message), "sensor %s received event: %s",
+ ssnprintf(n.message, sizeof(n.message), "sensor %s received event: %s",
n.type_instance, event_state);
DEBUG("Discrete event received for sensor %s", n.type_instance);
/* The `st->name` is used as "domain name" for ipmi_open_domain().
* That value should be unique, so we do plugin_register_complex_read()
* at first as it checks the uniqueness. */
- snprintf(callback_name, sizeof(callback_name), "ipmi/%s", st->name);
+ ssnprintf(callback_name, sizeof(callback_name), "ipmi/%s", st->name);
user_data_t ud = {
.data = st,
sstrncpy(vl.plugin, "ip6tables", sizeof(vl.plugin));
- status = snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
+ 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;
sstrncpy(vl.type_instance, chain->name, sizeof(vl.type_instance));
} else {
if (chain->rule_type == RTYPE_NUM)
- snprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
+ ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
chain->rule.num);
else
sstrncpy(vl.type_instance, (char *)match->data, sizeof(vl.type_instance));
sstrncpy(vl.plugin, "iptables", sizeof(vl.plugin));
- status = snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
+ 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;
sstrncpy(vl.type_instance, chain->name, sizeof(vl.type_instance));
} else {
if (chain->rule_type == RTYPE_NUM)
- snprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
+ ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
chain->rule.num);
else
sstrncpy(vl.type_instance, (char *)match->data, sizeof(vl.type_instance));
if (pool_busy_cpus < 0.0)
pool_busy_cpus = 0.0;
- snprintf(typinst, sizeof(typinst), "pool-%X-busy", lparstats.pool_id);
+ ssnprintf(typinst, sizeof(typinst), "pool-%X-busy", lparstats.pool_id);
lpar_submit(typinst, pool_busy_cpus);
- snprintf(typinst, sizeof(typinst), "pool-%X-idle", lparstats.pool_id);
+ ssnprintf(typinst, sizeof(typinst), "pool-%X-idle", lparstats.pool_id);
lpar_submit(typinst, pool_idle_cpus);
}
char subname[DATA_MAX_NAME_LEN];
if (!lua_isfunction(L, 1) && lua_isstring(L, 1)) {
const char *fname = lua_tostring(L, 1);
- snprintf(subname, sizeof(subname), "%s()", fname);
+ ssnprintf(subname, sizeof(subname), "%s()", fname);
lua_getglobal(L, fname); // Push function into stack
lua_remove(L, 1); // Remove string from stack
} else {
lua_getfield(L, LUA_REGISTRYINDEX, "collectd:callback_num");
int tmp = lua_tointeger(L, -1);
- snprintf(subname, sizeof(subname), "callback_%d", tmp);
+ ssnprintf(subname, sizeof(subname), "callback_%d", tmp);
lua_pop(L, 1); // Remove old value from stack
lua_pushinteger(L, tmp + 1);
lua_setfield(L, LUA_REGISTRYINDEX, "collectd:callback_num"); // pops value
lua_getfield(L, LUA_REGISTRYINDEX, "collectd:script_path");
char function_name[DATA_MAX_NAME_LEN];
- snprintf(function_name, sizeof(function_name), "lua/%s/%s",
+ ssnprintf(function_name, sizeof(function_name), "lua/%s/%s",
lua_tostring(L, -1), subname);
lua_pop(L, 1);
if (base_path[0] == '\0')
sstrncpy(abs_path, rel_path, sizeof(abs_path));
else
- snprintf(abs_path, sizeof(abs_path), "%s/%s", base_path, rel_path);
+ ssnprintf(abs_path, sizeof(abs_path), "%s/%s", base_path, rel_path);
DEBUG("Lua plugin: abs_path = \"%s\";", abs_path);
return;
used_bytes = lv_size * (used_percent_unscaled * PERCENT_SCALE_FACTOR);
- snprintf(plugin_instance, sizeof(plugin_instance), "%s-%s", vg_name, lv_name);
+ ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-%s", vg_name, lv_name);
lvm_submit(plugin_instance, "used", used_bytes);
lvm_submit(plugin_instance, "free", lv_size - used_bytes);
}
vl.values_len = 1;
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
strncpy(vl.type, "memory", sizeof(vl.type));
strncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
vl.values_len = 1;
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
strncpy(vl.type, "temperature", sizeof(vl.type));
strncpy(vl.type_instance, type, sizeof(vl.type_instance));
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
if (core < 0) /* global aggregation */
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
else /* per-core statistics */
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i-cpu-%i",
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i-cpu-%i",
micnumber, core);
strncpy(vl.type, "cpu", sizeof(vl.type));
strncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
vl.values_len = 1;
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
strncpy(vl.type, type, sizeof(vl.type));
strncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
return EINVAL;
if (slave->instance[0] == 0)
- snprintf(slave->instance, sizeof(slave->instance), "slave_%i", slave->id);
+ ssnprintf(slave->instance, sizeof(slave->instance), "slave_%i", slave->id);
vl.values = &value;
vl.values_len = 1;
if (status == 0) {
char name[1024];
- snprintf(name, sizeof(name), "modbus-%s", host->host);
+ ssnprintf(name, sizeof(name), "modbus-%s", host->host);
plugin_register_complex_read(/* group = */ NULL, name,
/* callback = */ mb_read,
if (status != 0)
return status;
- status = snprintf(buf, buf_len, "%s/%s", conf->topic_prefix, name);
+ status = ssnprintf(buf, buf_len, "%s/%s", conf->topic_prefix, name);
if ((status < 0) || (((size_t)status) >= buf_len))
return ENOMEM;
ERROR("mqtt plugin: Unknown config option: %s", child->key);
}
- snprintf(cb_name, sizeof(cb_name), "mqtt/%s", conf->name);
+ ssnprintf(cb_name, sizeof(cb_name), "mqtt/%s", conf->name);
plugin_register_write(cb_name, mqtt_write,
&(user_data_t){
.data = conf,
(db->database != NULL) ? db->database : "<default>");
if (db->instance != NULL)
- snprintf(cb_name, sizeof(cb_name), "mysql-%s", db->instance);
+ ssnprintf(cb_name, sizeof(cb_name), "mysql-%s", db->instance);
else
sstrncpy(cb_name, "mysql", sizeof(cb_name));
if (((io == NULL) || (strcasecmp(io, "yes") != 0)) &&
(db->slave_io_running)) {
n.severity = NOTIF_WARNING;
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"slave I/O thread not started or not connected to master");
plugin_dispatch_notification(&n);
db->slave_io_running = false;
} else if (((io != NULL) && (strcasecmp(io, "yes") == 0)) &&
(!db->slave_io_running)) {
n.severity = NOTIF_OKAY;
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"slave I/O thread started and connected to master");
plugin_dispatch_notification(&n);
db->slave_io_running = true;
if (((sql == NULL) || (strcasecmp(sql, "yes") != 0)) &&
(db->slave_sql_running)) {
n.severity = NOTIF_WARNING;
- snprintf(n.message, sizeof(n.message), "slave SQL thread not started");
+ ssnprintf(n.message, sizeof(n.message), "slave SQL thread not started");
plugin_dispatch_notification(&n);
db->slave_sql_running = false;
} else if (((sql != NULL) && (strcasecmp(sql, "yes") == 0)) &&
(!db->slave_sql_running)) {
n.severity = NOTIF_OKAY;
- snprintf(n.message, sizeof(n.message), "slave SQL thread started");
+ ssnprintf(n.message, sizeof(n.message), "slave SQL thread started");
plugin_dispatch_notification(&n);
db->slave_sql_running = true;
}
if ((hostname == NULL) || (old_data == NULL) || (new_data == NULL))
return -1;
- snprintf(plugin_instance, sizeof(plugin_instance), "volume-%s",
+ ssnprintf(plugin_instance, sizeof(plugin_instance), "volume-%s",
old_data->name);
/* Check for and submit disk-octet values */
uint64_t snap_reserve_free = v->snap_reserved;
uint64_t snap_norm_used = v->snap_used;
- snprintf(plugin_instance, sizeof(plugin_instance), "volume-%s", v->name);
+ ssnprintf(plugin_instance, sizeof(plugin_instance), "volume-%s", v->name);
if (HAS_ALL_FLAGS(v->flags,
HAVE_VOLUME_USAGE_SNAP_USED |
if ((v->flags & IS_VOLUME_USAGE_OFFLINE) != 0) {
n.severity = NOTIF_OKAY;
- snprintf(n.message, sizeof(n.message), "Volume %s is now online.", v->name);
+ ssnprintf(n.message, sizeof(n.message), "Volume %s is now online.", v->name);
v->flags &= ~IS_VOLUME_USAGE_OFFLINE;
} else {
n.severity = NOTIF_WARNING;
- snprintf(n.message, sizeof(n.message), "Volume %s is now offline.",
+ ssnprintf(n.message, sizeof(n.message), "Volume %s is now offline.",
v->name);
v->flags |= IS_VOLUME_USAGE_OFFLINE;
}
if (volume_name == NULL)
continue;
- snprintf(plugin_instance, sizeof(plugin_instance), "quota-%s-%s",
+ ssnprintf(plugin_instance, sizeof(plugin_instance), "quota-%s-%s",
volume_name, tree_name);
value = na_child_get_uint64(elem_quota, "disk-used", UINT64_MAX);
continue;
/* possible TODO: make plugin instance configurable */
- snprintf(plugin_instance, sizeof(plugin_instance), "snapvault-%s",
+ ssnprintf(plugin_instance, sizeof(plugin_instance), "snapvault-%s",
dest_path);
submit_double(hostname, plugin_instance, /* type = */ "delay", NULL,
(double)value, /* timestamp = */ 0, interval);
char cb_name[256];
if (host->vfiler)
- snprintf(cb_name, sizeof(cb_name), "netapp-%s-%s", host->name,
+ ssnprintf(cb_name, sizeof(cb_name), "netapp-%s-%s", host->name,
host->vfiler);
else
- snprintf(cb_name, sizeof(cb_name), "netapp-%s", host->name);
+ ssnprintf(cb_name, sizeof(cb_name), "netapp-%s", host->name);
plugin_register_complex_read(
/* group = */ NULL, cb_name,
if (strcmp(tc_type, "filter") == 0)
numberic_id = tm->tcm_parent;
- snprintf(tc_inst, sizeof(tc_inst), "%s-%x:%x", kind, numberic_id >> 16,
+ ssnprintf(tc_inst, sizeof(tc_inst), "%s-%x:%x", kind, numberic_id >> 16,
numberic_id & 0x0000FFFF);
}
stats_submitted = true;
- int r = snprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
+ int r = ssnprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
tc_inst);
if ((size_t)r >= sizeof(type_instance)) {
ERROR("netlink plugin: type_instance truncated to %zu bytes, need %d",
if (!stats_submitted && ts != NULL) {
char type_instance[DATA_MAX_NAME_LEN];
- int r = snprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
+ int r = ssnprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
tc_inst);
if ((size_t)r >= sizeof(type_instance)) {
ERROR("netlink plugin: type_instance truncated to %zu bytes, need %d",
curl_easy_setopt(curl, CURLOPT_PASSWORD, (pass == NULL) ? "" : pass);
#else
static char credentials[1024];
- int status = snprintf(credentials, sizeof(credentials), "%s:%s", user,
+ int status = ssnprintf(credentials, sizeof(credentials), "%s:%s", user,
pass == NULL ? "" : pass);
if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
ERROR("nginx plugin: Credentials would have been truncated.");
timeout = fail_timeout;
}
- snprintf(summary, sizeof(summary), "collectd %s notification",
+ ssnprintf(summary, sizeof(summary), "collectd %s notification",
(NOTIF_FAILURE == n->severity)
? "FAILURE"
: (NOTIF_WARNING == n->severity)
static int notify_email_init(void) {
char server[MAXSTRING];
- snprintf(server, sizeof(server), "%s:%i",
+ ssnprintf(server, sizeof(server), "%s:%i",
(smtp_host == NULL) ? DEFAULT_SMTP_HOST : smtp_host, smtp_port);
pthread_mutex_lock(&session_lock);
char *buf_ptr = buf;
int buf_len = sizeof(buf);
- snprintf(severity, sizeof(severity), "%s",
+ ssnprintf(severity, sizeof(severity), "%s",
(n->severity == NOTIF_FAILURE)
? "FAILURE"
: ((n->severity == NOTIF_WARNING)
? "WARNING"
: ((n->severity == NOTIF_OKAY) ? "OKAY" : "UNKNOWN")));
- snprintf(subject, sizeof(subject),
+ ssnprintf(subject, sizeof(subject),
(email_subject == NULL) ? DEFAULT_SMTP_SUBJECT : email_subject,
severity, n->host);
timestamp_str[sizeof(timestamp_str) - 1] = '\0';
/* Let's make RFC822 message text with \r\n EOLs */
- int status = snprintf(buf, buf_len,
+ int status = ssnprintf(buf, buf_len,
"MIME-Version: 1.0\r\n"
"Content-Type: text/plain; charset=\"US-ASCII\"\r\n"
"Content-Transfer-Encoding: 8bit\r\n"
#define APPEND(format, value) \
if ((buf_len > 0) && (strlen(value) > 0)) { \
- status = snprintf(buf_ptr, buf_len, format "\r\n", value); \
+ status = ssnprintf(buf_ptr, buf_len, format "\r\n", value); \
if (status > 0) { \
buf_ptr += status; \
buf_len -= status; \
char file[4096];
char *endptr;
- snprintf(file, sizeof(file), "%s/%s", path,
+ ssnprintf(file, sizeof(file), "%s/%s", path,
family_info->features[i].filename);
file[sizeof(file) - 1] = '\0';
char subpath[4096];
int status;
- status = snprintf(subpath, sizeof(subpath), "%s/main", path);
+ status = ssnprintf(subpath, sizeof(subpath), "%s/main", path);
if ((status > 0) && (status < (int)sizeof(subpath)))
cow_read_bus(subpath);
- status = snprintf(subpath, sizeof(subpath), "%s/aux", path);
+ status = ssnprintf(subpath, sizeof(subpath), "%s/aux", path);
if ((status > 0) && (status < (int)sizeof(subpath)))
cow_read_bus(subpath);
dummy = NULL;
if (strcmp("/", path) == 0)
- status = snprintf(subpath, sizeof(subpath), "/%s", buffer_ptr);
+ status = ssnprintf(subpath, sizeof(subpath), "/%s", buffer_ptr);
else
- status = snprintf(subpath, sizeof(subpath), "%s/%s", path, buffer_ptr);
+ status = ssnprintf(subpath, sizeof(subpath), "%s/%s", path, buffer_ptr);
if ((status <= 0) || (status >= (int)sizeof(subpath)))
continue;
if ((olmbdb_list =
ldap_get_values_len(st->ld, e, "olmBDBEntryCache")) != NULL) {
olmbdb_data = *olmbdb_list[0];
- snprintf(typeinst, sizeof(typeinst), "bdbentrycache-%s",
+ ssnprintf(typeinst, sizeof(typeinst), "bdbentrycache-%s",
nc_data.bv_val);
cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
st);
if ((olmbdb_list = ldap_get_values_len(st->ld, e, "olmBDBDNCache")) !=
NULL) {
olmbdb_data = *olmbdb_list[0];
- snprintf(typeinst, sizeof(typeinst), "bdbdncache-%s", nc_data.bv_val);
+ ssnprintf(typeinst, sizeof(typeinst), "bdbdncache-%s", nc_data.bv_val);
cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
st);
ldap_value_free_len(olmbdb_list);
if ((olmbdb_list = ldap_get_values_len(st->ld, e, "olmBDBIDLCache")) !=
NULL) {
olmbdb_data = *olmbdb_list[0];
- snprintf(typeinst, sizeof(typeinst), "bdbidlcache-%s",
+ ssnprintf(typeinst, sizeof(typeinst), "bdbidlcache-%s",
nc_data.bv_val);
cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
st);
char callback_name[3 * DATA_MAX_NAME_LEN] = {0};
- snprintf(callback_name, sizeof(callback_name), "openldap/%s/%s",
+ ssnprintf(callback_name, sizeof(callback_name), "openldap/%s/%s",
(st->host != NULL) ? st->host : hostname_g,
(st->name != NULL) ? st->name : "default");
if ((status != OCI_SUCCESS) && (status != OCI_SUCCESS_WITH_INFO)) {
char errfunc[256];
- snprintf(errfunc, sizeof(errfunc), "OCILogon(\"%s\")", db->connect_id);
+ ssnprintf(errfunc, sizeof(errfunc), "OCILogon(\"%s\")", db->connect_id);
o_report_error("o_read_database", db->name, NULL, errfunc, oci_error);
DEBUG("oracle plugin: OCILogon (%s): db->oci_service_context = %p;",
return NULL;
}
opt_buff = new_buff;
- int ret = snprintf(opt_buff + buff_off, buff_size - buff_off, option_fmt,
+ int ret = ssnprintf(opt_buff + buff_off, buff_size - buff_off, option_fmt,
iface->name);
if (ret < 0) {
sfree(opt_buff);
}
/* fill the notification data */
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"link state of \"%s\" interface has been changed to \"%s\"",
ifinfo->name, msg_link_status);
sstrncpy(n.host, hostname_g, sizeof(n.host));
for (interface_list_t *iface = port->iface; iface != NULL;
iface = iface->next) {
- snprintf(key_str, sizeof(key_str), "uuid%d", i);
+ ssnprintf(key_str, sizeof(key_str), "uuid%d", i);
meta_data_add_string(meta, key_str, iface->iface_uuid);
if (strlen(iface->ex_vm_id)) {
- snprintf(key_str, sizeof(key_str), "vm-uuid%d", i);
+ ssnprintf(key_str, sizeof(key_str), "vm-uuid%d", i);
meta_data_add_string(meta, key_str, iface->ex_vm_id);
}
if (strlen(iface->ex_iface_id)) {
- snprintf(key_str, sizeof(key_str), "iface-id%d", i);
+ ssnprintf(key_str, sizeof(key_str), "iface-id%d", i);
meta_data_add_string(meta, key_str, iface->ex_iface_id);
}
}
}
bridge_list_t *bridge = port->br;
- snprintf(devname, sizeof(devname), "%s.%s", bridge->name, port->name);
+ ssnprintf(devname, sizeof(devname), "%s.%s", bridge->name, port->name);
ovs_stats_submit_one(devname, "if_collisions", NULL,
ovs_stats_get_port_stat_value(port, collisions), meta);
ovs_stats_submit_two(devname, "if_dropped", NULL,
static char *get_module_name(char *buf, size_t buf_len, const char *module) {
int status = 0;
if (base_name[0] == '\0')
- status = snprintf(buf, buf_len, "%s", module);
+ status = ssnprintf(buf, buf_len, "%s", module);
else
- status = snprintf(buf, buf_len, "%s::%s", base_name, module);
+ status = ssnprintf(buf, buf_len, "%s::%s", base_name, module);
if ((status < 0) || ((unsigned int)status >= buf_len))
return NULL;
return buf;
* is ignored. */
#define C_PSQL_PAR_APPEND(buf, buf_len, parameter, value) \
if ((0 < (buf_len)) && (NULL != (value)) && ('\0' != *(value))) { \
- int s = snprintf(buf, buf_len, " %s = '%s'", parameter, value); \
+ int s = ssnprintf(buf, buf_len, " %s = '%s'", parameter, value); \
if (0 < s) { \
buf += s; \
buf_len -= s; \
if ((!db) || (!db->database))
return -1;
- status = snprintf(buf, buf_len, "dbname = '%s'", db->database);
+ status = ssnprintf(buf, buf_len, "dbname = '%s'", db->database);
if (0 < status) {
buf += status;
buf_len -= status;
params[i] = db->user;
break;
case C_PSQL_PARAM_INTERVAL:
- snprintf(interval, sizeof(interval), "%.3f",
+ ssnprintf(interval, sizeof(interval), "%.3f",
CDTIME_T_TO_DOUBLE(plugin_get_interval()));
params[i] = interval;
break;
str_len = string_len;
for (size_t i = 0; i < ds->ds_num; ++i) {
- int status = snprintf(str_ptr, str_len, ",'%s'", ds->ds[i].name);
+ int status = ssnprintf(str_ptr, str_len, ",'%s'", ds->ds[i].name);
if (status < 1)
return NULL;
int status;
if (store_rates)
- status = snprintf(str_ptr, str_len, ",'gauge'");
+ status = ssnprintf(str_ptr, str_len, ",'gauge'");
else
- status = snprintf(str_ptr, str_len, ",'%s'",
+ status = ssnprintf(str_ptr, str_len, ",'%s'",
DS_TYPE_TO_STRING(ds->ds[i].type));
if (status < 1) {
if (ds->ds[i].type == DS_TYPE_GAUGE)
status =
- snprintf(str_ptr, str_len, "," GAUGE_FORMAT, vl->values[i].gauge);
+ ssnprintf(str_ptr, str_len, "," GAUGE_FORMAT, vl->values[i].gauge);
else if (store_rates) {
if (rates == NULL)
rates = uc_get_rate(ds, vl);
return NULL;
}
- status = snprintf(str_ptr, str_len, ",%lf", rates[i]);
+ status = ssnprintf(str_ptr, str_len, ",%lf", rates[i]);
} else if (ds->ds[i].type == DS_TYPE_COUNTER)
- status = snprintf(str_ptr, str_len, ",%" PRIu64,
+ status = ssnprintf(str_ptr, str_len, ",%" PRIu64,
(uint64_t)vl->values[i].counter);
else if (ds->ds[i].type == DS_TYPE_DERIVE)
- status = snprintf(str_ptr, str_len, ",%" PRIi64, vl->values[i].derive);
+ status = ssnprintf(str_ptr, str_len, ",%" PRIi64, vl->values[i].derive);
else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
- status = snprintf(str_ptr, str_len, ",%" PRIu64, vl->values[i].absolute);
+ status = ssnprintf(str_ptr, str_len, ",%" PRIu64, vl->values[i].absolute);
if (status < 1) {
str_len = 0;
if (db->writers_num > 0) {
char cb_name[DATA_MAX_NAME_LEN];
- snprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->database);
+ ssnprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->database);
if (!had_flush) {
plugin_unregister_flush("postgresql");
}
}
- snprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->instance);
+ ssnprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->instance);
user_data_t ud = {.data = db, .free_func = c_psql_database_delete};
if (values_list != NULL) {
char match_name[2 * DATA_MAX_NAME_LEN];
- snprintf(match_name, sizeof(match_name), "%s:%s", key_buffer,
+ ssnprintf(match_name, sizeof(match_name), "%s:%s", key_buffer,
key_fields[i]);
if (ignorelist_match(values_list, match_name))
PyObject *mod = NULL;
if (name != NULL) {
- snprintf(buf, size, "python.%s", name);
+ ssnprintf(buf, size, "python.%s", name);
return;
}
module = cpy_unicode_or_bytes_to_string(&mod);
if (module != NULL) {
- snprintf(buf, size, "python.%s", module);
+ ssnprintf(buf, size, "python.%s", module);
Py_XDECREF(mod);
PyErr_Clear();
return;
}
Py_XDECREF(mod);
- snprintf(buf, size, "python.%p", callback);
+ ssnprintf(buf, size, "python.%p", callback);
PyErr_Clear();
}
redis_have_instances = true;
char cb_name[sizeof("redis/") + DATA_MAX_NAME_LEN];
- snprintf(cb_name, sizeof(cb_name), "redis/%s", rn->name);
+ ssnprintf(cb_name, sizeof(cb_name), "redis/%s", rn->name);
return plugin_register_complex_read(
/* group = */ "redis",
char *str;
int i;
- snprintf(field_name, sizeof(field_name), "db%d:keys=", db);
+ ssnprintf(field_name, sizeof(field_name), "db%d:keys=", db);
str = strstr(info_line, field_name);
if (!str)
return -1;
}
- snprintf(db_id, sizeof(db_id), "%d", db);
+ ssnprintf(db_id, sizeof(db_id), "%d", db);
redis_submit(node, "records", db_id, val);
}
return 0;
name = "default";
/*** RX ***/
- snprintf(type_instance, sizeof(type_instance), "%s-%s-rx", r->interface,
+ ssnprintf(type_instance, sizeof(type_instance), "%s-%s-rx", r->interface,
name);
cr_submit_gauge(rd, "bitrate", type_instance,
(gauge_t)(1000000.0 * r->rx_rate));
cr_submit_gauge(rd, "signal_quality", type_instance, (gauge_t)r->rx_ccq);
/*** TX ***/
- snprintf(type_instance, sizeof(type_instance), "%s-%s-tx", r->interface,
+ ssnprintf(type_instance, sizeof(type_instance), "%s-%s-tx", r->interface,
name);
cr_submit_gauge(rd, "bitrate", type_instance,
(gauge_t)(1000000.0 * r->tx_rate));
cr_submit_gauge(rd, "signal_quality", type_instance, (gauge_t)r->tx_ccq);
/*** RX / TX ***/
- snprintf(type_instance, sizeof(type_instance), "%s-%s", r->interface, name);
+ ssnprintf(type_instance, sizeof(type_instance), "%s-%s", r->interface, name);
cr_submit_io(rd, "if_octets", type_instance, (derive_t)r->rx_bytes,
(derive_t)r->tx_bytes);
cr_submit_gauge(rd, "snr", type_instance, (gauge_t)r->signal_to_noise);
return status;
}
- snprintf(read_name, sizeof(read_name), "routeros/%s", router_data->node);
+ ssnprintf(read_name, sizeof(read_name), "routeros/%s", router_data->node);
return plugin_register_complex_read(
/* group = */ NULL, read_name, cr_read, /* interval = */ 0,
&(user_data_t){
memset(buffer, '\0', buffer_len);
int status =
- snprintf(buffer, buffer_len, "%.6f", CDTIME_T_TO_DOUBLE(vl->time));
+ ssnprintf(buffer, buffer_len, "%.6f", CDTIME_T_TO_DOUBLE(vl->time));
if ((status < 1) || (status >= buffer_len))
return -1;
int offset = status;
return -1;
if (ds->ds[i].type == DS_TYPE_COUNTER) {
- status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
(uint64_t)vl->values[i].counter);
} else if (ds->ds[i].type == DS_TYPE_GAUGE) {
- status = snprintf(buffer + offset, buffer_len - offset, ":%f",
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%f",
vl->values[i].gauge);
} else if (ds->ds[i].type == DS_TYPE_DERIVE) {
- status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
vl->values[i].derive);
} else /* if (ds->ds[i].type == DS_TYPE_ABSOLUTE) */ {
- status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
vl->values[i].absolute);
}
char filename[PATH_MAX + 1];
if (datadir != NULL)
- snprintf(filename, sizeof(filename), "%s/%s.rrd", datadir, identifier);
+ ssnprintf(filename, sizeof(filename), "%s/%s.rrd", datadir, identifier);
else
- snprintf(filename, sizeof(filename), "%s.rrd", identifier);
+ ssnprintf(filename, sizeof(filename), "%s.rrd", identifier);
rrd_clear_error();
int status = rrdc_connect(daemon_address);
memset(buffer, '\0', buffer_len);
tt = CDTIME_T_TO_TIME_T(vl->time);
- status = snprintf(buffer, buffer_len, "%u", (unsigned int)tt);
+ status = ssnprintf(buffer, buffer_len, "%u", (unsigned int)tt);
if ((status < 1) || (status >= buffer_len))
return -1;
offset = status;
return -1;
if (ds->ds[i].type == DS_TYPE_COUNTER)
- status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
(uint64_t)vl->values[i].counter);
else if (ds->ds[i].type == DS_TYPE_GAUGE)
- status = snprintf(buffer + offset, buffer_len - offset, ":" GAUGE_FORMAT,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":" GAUGE_FORMAT,
vl->values[i].gauge);
else if (ds->ds[i].type == DS_TYPE_DERIVE)
- status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
vl->values[i].derive);
else /*if (ds->ds[i].type == DS_TYPE_ABSOLUTE) */
- status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
+ status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
vl->values[i].absolute);
if ((status < 1) || (status >= (buffer_len - offset)))
tt = CDTIME_T_TO_TIME_T(vl->time);
switch (ds->ds[0].type) {
case DS_TYPE_DERIVE:
- status = snprintf(buffer, buffer_len, "%u:%" PRIi64, (unsigned)tt,
+ status = ssnprintf(buffer, buffer_len, "%u:%" PRIi64, (unsigned)tt,
vl->values[0].derive);
break;
case DS_TYPE_GAUGE:
- status = snprintf(buffer, buffer_len, "%u:" GAUGE_FORMAT, (unsigned)tt,
+ status = ssnprintf(buffer, buffer_len, "%u:" GAUGE_FORMAT, (unsigned)tt,
vl->values[0].gauge);
break;
case DS_TYPE_COUNTER:
- status = snprintf(buffer, buffer_len, "%u:%" PRIu64, (unsigned)tt,
+ status = ssnprintf(buffer, buffer_len, "%u:%" PRIu64, (unsigned)tt,
(uint64_t)vl->values[0].counter);
break;
case DS_TYPE_ABSOLUTE:
- status = snprintf(buffer, buffer_len, "%u:%" PRIu64, (unsigned)tt,
+ status = ssnprintf(buffer, buffer_len, "%u:%" PRIu64, (unsigned)tt,
vl->values[0].absolute);
break;
default:
now = cdtime();
if (datadir == NULL)
- snprintf(key, sizeof(key), "%s.rrd", identifier);
+ ssnprintf(key, sizeof(key), "%s.rrd", identifier);
else
- snprintf(key, sizeof(key), "%s/%s.rrd", datadir, identifier);
+ ssnprintf(key, sizeof(key), "%s/%s.rrd", datadir, identifier);
key[sizeof(key) - 1] = '\0';
status = c_avl_get(cache, key, (void *)&rc);
}
cfdev->sdi = devlist->data;
g_slist_free(devlist);
- snprintf(hwident, sizeof(hwident), "%s %s %s",
+ ssnprintf(hwident, sizeof(hwident), "%s %s %s",
cfdev->sdi->vendor ? cfdev->sdi->vendor : "",
cfdev->sdi->model ? cfdev->sdi->model : "",
cfdev->sdi->version ? cfdev->sdi->version : "");
sstrncpy(notif.host, hostname_g, sizeof(notif.host));
sstrncpy(notif.plugin_instance, name, sizeof(notif.plugin_instance));
sstrncpy(notif.type_instance, a->name, sizeof(notif.type_instance));
- snprintf(notif.message, sizeof(notif.message),
+ ssnprintf(notif.message, sizeof(notif.message),
"attribute %s is below allowed threshold (%d < %d)", a->name,
a->current_value, a->threshold);
plugin_dispatch_notification(¬if);
char *oid_str_ptr[MAX_OID_LEN];
for (size_t i = 0; i < o->oid_len; i++) {
- snprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
+ ssnprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
oid_str_ptr[i] = oid_str[i];
}
"= %i }",
hd->name, hd->address, hd->community, hd->version);
- snprintf(cb_name, sizeof(cb_name), "snmp-%s", hd->name);
+ ssnprintf(cb_name, sizeof(cb_name), "snmp-%s", hd->name);
status = plugin_register_complex_read(
/* group = */ NULL, cb_name, csnmp_read_host, interval,
for (size_t i = 0; i < vb->val_len; i++) {
int status;
- status = snprintf(buffer_ptr, buffer_free, (i == 0) ? "%02x" : ":%02x",
+ status = ssnprintf(buffer_ptr, buffer_free, (i == 0) ? "%02x" : ":%02x",
(unsigned int)vb->val.bitstring[i]);
assert(status >= 0);
else if (vb->type == ASN_BIT_STR)
src = (char *)vb->val.bitstring;
else if (vb->type == ASN_IPADDRESS) {
- return snprintf(dst, dst_size,
+ return ssnprintf(dst, dst_size,
"%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8 "",
(uint8_t)vb->val.string[0], (uint8_t)vb->val.string[1],
(uint8_t)vb->val.string[2], (uint8_t)vb->val.string[3]);
value_t val = csnmp_value_list_to_value(
vb, DS_TYPE_COUNTER,
/* scale = */ 1.0, /* shift = */ 0.0, hd->name, dd->name);
- snprintf(il->value, sizeof(il->value), "%" PRIu64, (uint64_t)val.counter);
+ ssnprintf(il->value, sizeof(il->value), "%" PRIu64, (uint64_t)val.counter);
}
return il;
if (data->host.prefix == NULL)
sstrncpy(vl.host, temp, sizeof(vl.host));
else
- snprintf(vl.host, sizeof(vl.host), "%s%s", data->host.prefix, temp);
+ ssnprintf(vl.host, sizeof(vl.host), "%s%s", data->host.prefix, temp);
} else {
sstrncpy(vl.host, host->name, sizeof(vl.host));
}
if (data->type_instance.prefix == NULL)
sstrncpy(vl.type_instance, temp, sizeof(vl.type_instance));
else
- snprintf(vl.type_instance, sizeof(vl.type_instance), "%s%s",
+ ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s%s",
data->type_instance.prefix, temp);
} else if (data->type_instance.value) {
sstrncpy(vl.type_instance, data->type_instance.value,
if (data->plugin_instance.prefix == NULL)
sstrncpy(vl.plugin_instance, temp, sizeof(vl.plugin_instance));
else
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s%s",
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s%s",
data->plugin_instance.prefix, temp);
} else if (data->plugin_instance.value) {
sstrncpy(vl.plugin_instance, data->plugin_instance.value,
char *oid_str_ptr[MAX_OID_LEN];
for (size_t i = 0; i < o->oid_len; i++) {
- snprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
+ ssnprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
oid_str_ptr[i] = oid_str[i];
}
if (index == NULL)
snmp_agent_oid_to_string(index_str, sizeof(index_str), index_oid);
else
- snprintf(index_str, sizeof(index_str), "%d", *index);
+ ssnprintf(index_str, sizeof(index_str), "%d", *index);
notification_t n = {
.severity = NOTIF_WARNING, .time = cdtime(), .plugin = PLUGIN_NAME};
sstrncpy(n.host, hostname_g, sizeof(n.host));
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"Removed data row from table %s with index %s", td->name, index_str);
DEBUG(PLUGIN_NAME ": %s", n.message);
plugin_dispatch_notification(&n);
strncat(out, tok->str, DATA_MAX_NAME_LEN - strlen(out) - 1);
if (tok->key != NULL) {
if (tok->key->type == ASN_INTEGER) {
- snprintf(str, sizeof(str), "%ld", *tok->key->val.integer);
+ ssnprintf(str, sizeof(str), "%ld", *tok->key->val.integer);
strncat(out, str, DATA_MAX_NAME_LEN - strlen(out) - 1);
} else /* OCTET_STR */
strncat(out, (char *)tok->key->val.string,
}
if (td->index_keys[i].type == ASN_INTEGER) {
- snprintf(str, sizeof(str), "%ld", *key->val.integer);
+ ssnprintf(str, sizeof(str), "%ld", *key->val.integer);
fields[source] = str;
} else /* OCTET_STR */
fields[source] = (char *)key->val.string;
case ASN_OCTET_STR:
if (type == DS_TYPE_GAUGE) {
char buf[DATA_MAX_NAME_LEN];
- snprintf(buf, sizeof(buf), "%.2f", val->gauge);
+ ssnprintf(buf, sizeof(buf), "%.2f", val->gauge);
if (*data_len < strlen(buf))
return -EINVAL;
*data_len = strlen(buf);
if (index == NULL)
snmp_agent_oid_to_string(index_str, sizeof(index_str), index_oid);
else
- snprintf(index_str, sizeof(index_str), "%d", *index);
+ ssnprintf(index_str, sizeof(index_str), "%d", *index);
notification_t n = {
.severity = NOTIF_OKAY, .time = cdtime(), .plugin = PLUGIN_NAME};
sstrncpy(n.host, hostname_g, sizeof(n.host));
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"Data added to table %s with index %s", td->name, index_str);
DEBUG(PLUGIN_NAME ": %s", n.message);
n.time = vl->time;
- status = snprintf(buf, bufsize, "Host %s, plugin %s", vl->host, vl->plugin);
+ status = ssnprintf(buf, bufsize, "Host %s, plugin %s", vl->host, vl->plugin);
buf += status;
bufsize -= status;
if (vl->plugin_instance[0] != '\0') {
- status = snprintf(buf, bufsize, " (instance %s)", vl->plugin_instance);
+ status = ssnprintf(buf, bufsize, " (instance %s)", vl->plugin_instance);
buf += status;
bufsize -= status;
}
- status = snprintf(buf, bufsize, " type %s", vl->type);
+ status = ssnprintf(buf, bufsize, " type %s", vl->type);
buf += status;
bufsize -= status;
if (vl->type_instance[0] != '\0') {
- status = snprintf(buf, bufsize, " (instance %s)", vl->type_instance);
+ status = ssnprintf(buf, bufsize, " (instance %s)", vl->type_instance);
buf += status;
bufsize -= status;
}
/* Send an okay notification */
if (state == STATE_OKAY) {
if (state_old == STATE_MISSING)
- snprintf(buf, bufsize, ": Value is no longer missing.");
+ ssnprintf(buf, bufsize, ": Value is no longer missing.");
else
- snprintf(buf, bufsize, ": All data sources are within range again. "
+ ssnprintf(buf, bufsize, ": All data sources are within range again. "
"Current value of \"%s\" is %f.",
ds->ds[ds_index].name, values[ds_index]);
} else if (state == STATE_UNKNOWN) {
if (th->flags & UT_FLAG_INVERT) {
if (!isnan(min) && !isnan(max)) {
- snprintf(buf, bufsize,
+ ssnprintf(buf, bufsize,
": Data source \"%s\" is currently "
"%f. That is within the %s region of %f%s and %f%s.",
ds->ds[ds_index].name, values[ds_index],
((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : "", max,
((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : "");
} else {
- snprintf(buf, bufsize, ": Data source \"%s\" is currently "
+ ssnprintf(buf, bufsize, ": Data source \"%s\" is currently "
"%f. That is %s the %s threshold of %f%s.",
ds->ds[ds_index].name, values[ds_index],
isnan(min) ? "below" : "above",
else
value = 100.0 * values[ds_index] / sum;
- snprintf(buf, bufsize,
+ ssnprintf(buf, bufsize,
": Data source \"%s\" is currently "
"%g (%.2f%%). That is %s the %s threshold of %.2f%%.",
ds->ds[ds_index].name, values[ds_index], value,
(value < min) ? min : max);
} else /* is not inverted */
{
- snprintf(buf, bufsize, ": Data source \"%s\" is currently "
+ ssnprintf(buf, bufsize, ": Data source \"%s\" is currently "
"%f. That is %s the %s threshold of %f.",
ds->ds[ds_index].name, values[ds_index],
(values[ds_index] < min) ? "below" : "above",
FORMAT_VL(identifier, sizeof(identifier), vl);
NOTIFICATION_INIT_VL(&n, vl);
- snprintf(n.message, sizeof(n.message),
+ ssnprintf(n.message, sizeof(n.message),
"%s has not been updated for %.3f seconds.", identifier,
CDTIME_T_TO_DOUBLE(missing_time));
n.time = now;
memset(&cmd, 0, sizeof(cmd));
status = cmd_parse(input, &cmd, parse_data[i].opts, &err);
- snprintf(description, sizeof(description), "cmd_parse (\"%s\", opts=%p) = "
+ ssnprintf(description, sizeof(description), "cmd_parse (\"%s\", opts=%p) = "
"%d (type=%d [%s]); want %d "
"(type=%d [%s])",
parse_data[i].input, parse_data[i].opts, status, cmd.type,
return dest;
} /* char *sstrncpy */
+/* ssnprintf returns zero on success, one if truncation occurred
+ and a negative integer onerror. */
+int ssnprintf(char *str, size_t sz, const char *format, ...) {
+ va_list ap;
+ va_start(ap, format);
+
+ int ret = vsnprintf(str, sz, format, ap);
+
+ va_end(ap);
+
+ if (ret < 0) {
+ return ret;
+ }
+ return (size_t)ret >= sz;
+} /* int ssnprintf */
+
char *ssnprintf_alloc(char const *format, ...) /* {{{ */
{
char static_buffer[1024] = "";
char *sstrncpy(char *dest, const char *src, size_t n);
+__attribute__((format(printf, 3, 4))) int ssnprintf(char *str, size_t size,
+ char const *format, ...);
+
__attribute__((format(printf, 1, 2))) char *ssnprintf_alloc(char const *format,
...);
} else {
for (size_t j = 0; j < n && cg_idx < STATIC_ARRAY_SIZE(cgroups); j++) {
char desc[DATA_MAX_NAME_LEN];
- snprintf(desc, sizeof(desc), "%u", cores[j]);
+ ssnprintf(desc, sizeof(desc), "%u", cores[j]);
cgroups[cg_idx].desc = strdup(desc);
if (cgroups[cg_idx].desc == NULL) {
for (int i = 0; i < num_cores; i++) {
char desc[DATA_MAX_NAME_LEN];
- snprintf(desc, sizeof(desc), "%d", i);
+ ssnprintf(desc, sizeof(desc), "%d", i);
cgl->cgroups[i].cores = calloc(1, sizeof(*(cgl->cgroups[i].cores)));
if (cgl->cgroups[i].cores == NULL) {
}
tmp[sizeof(tmp) - 1] = '\0';
- snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s",
+ ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s",
r->instance_prefix, tmp);
}
}
return "ANY"; /* ... 255 */
#endif /* __BIND >= 19950621 */
default:
- snprintf(buf, sizeof(buf), "#%i", t);
+ ssnprintf(buf, sizeof(buf), "#%i", t);
return buf;
} /* switch (t) */
}
case 5:
return "Update";
default:
- snprintf(buf, sizeof(buf), "Opcode%d", o);
+ ssnprintf(buf, sizeof(buf), "Opcode%d", o);
return buf;
}
}
#endif /* RFC2136 rcodes */
#endif /* __BIND >= 19950621 */
default:
- snprintf(buf, sizeof(buf), "RCode%i", rcode);
+ ssnprintf(buf, sizeof(buf), "RCode%i", rcode);
return buf;
}
} /* const char *rcode_str (int rcode) */
DPDK_HELPER_TRACE(phc->shm_name);
- snprintf(phc->eal_config.coremask, DATA_MAX_NAME_LEN, "%s", "0xf");
- snprintf(phc->eal_config.memory_channels, DATA_MAX_NAME_LEN, "%s", "1");
- snprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN, "%s",
+ ssnprintf(phc->eal_config.coremask, DATA_MAX_NAME_LEN, "%s", "0xf");
+ ssnprintf(phc->eal_config.memory_channels, DATA_MAX_NAME_LEN, "%s", "1");
+ ssnprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN, "%s",
DPDK_DEFAULT_RTE_CONFIG);
}
status = cf_util_get_string_buffer(child, prefix, sizeof(prefix));
if (status == 0) {
#if RTE_VERSION <= RTE_VERSION_NUM(18, 5, 0, 0)
- snprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN,
+ ssnprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN,
"/var/run/.%s_config", prefix);
#else
- snprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN,
+ ssnprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN,
"/var/run/dpdk/%s/config", prefix);
#endif
DEBUG("dpdk_common: EAL:File prefix %s", phc->eal_config.file_prefix);
};
char want[1024];
- snprintf(want, sizeof(want), "%s 42 1480063672\r\n", cases[i].want_name);
+ ssnprintf(want, sizeof(want), "%s 42 1480063672\r\n", cases[i].want_name);
if (cases[i].plugin_instance != NULL)
sstrncpy(vl.plugin_instance, cases[i].plugin_instance,
}
case DS_TYPE_DERIVE: {
derive_t diff = v.derive - (derive_t)start_value;
- snprintf(integer, sizeof(integer), "%" PRIi64, diff);
+ ssnprintf(integer, sizeof(integer), "%" PRIi64, diff);
break;
}
case DS_TYPE_COUNTER: {
counter_t diff = counter_diff((counter_t)start_value, v.counter);
- snprintf(integer, sizeof(integer), "%llu", diff);
+ ssnprintf(integer, sizeof(integer), "%llu", diff);
break;
}
case DS_TYPE_ABSOLUTE: {
- snprintf(integer, sizeof(integer), "%" PRIu64, v.absolute);
+ ssnprintf(integer, sizeof(integer), "%" PRIu64, v.absolute);
break;
}
default: {
#define GCM_PREFIX "custom.googleapis.com/collectd/"
if ((ds_index != 0) || strcmp("value", ds_name) != 0) {
- snprintf(buffer, buffer_size, GCM_PREFIX "%s/%s_%s", vl->plugin, vl->type,
+ ssnprintf(buffer, buffer_size, GCM_PREFIX "%s/%s_%s", vl->plugin, vl->type,
ds_name);
} else {
- snprintf(buffer, buffer_size, GCM_PREFIX "%s/%s", vl->plugin, vl->type);
+ ssnprintf(buffer, buffer_size, GCM_PREFIX "%s/%s", vl->plugin, vl->type);
}
char const *whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
}
char start_value_key[DATA_MAX_NAME_LEN];
- snprintf(start_value_key, sizeof(start_value_key),
+ ssnprintf(start_value_key, sizeof(start_value_key),
"stackdriver:start_value[%d]", ds_index);
int status =
{
char url[1024];
- snprintf(url, sizeof(url), GCE_SCOPE_URL_FORMAT,
+ ssnprintf(url, sizeof(url), GCE_SCOPE_URL_FORMAT,
(email != NULL) ? email : GCE_DEFAULT_SERVICE_ACCOUNT);
return read_url(url);
return 0;
}
- snprintf(url, sizeof(url), GCE_TOKEN_URL_FORMAT, email);
+ ssnprintf(url, sizeof(url), GCE_TOKEN_URL_FORMAT, email);
json = read_url(url);
if (json == NULL) {
pthread_mutex_unlock(&token_lock);
/* create the claim set */
status =
- snprintf(claim, sizeof(claim), OAUTH_CLAIM_FORMAT, auth->iss, auth->scope,
+ ssnprintf(claim, sizeof(claim), OAUTH_CLAIM_FORMAT, auth->iss, auth->scope,
auth->aud, (unsigned long)CDTIME_T_TO_TIME_T(exp),
(unsigned long)CDTIME_T_TO_TIME_T(iat));
if (status < 1)
int status;
/* Make the string to sign */
- payload_len = snprintf(payload, sizeof(payload), "%s.%s", header, claim);
+ payload_len = ssnprintf(payload, sizeof(payload), "%s.%s", header, claim);
if (payload_len < 1) {
return -1;
} else if (payload_len >= sizeof(payload)) {
if (status != 0)
return -1;
- status = snprintf(buffer, buffer_size, "%s.%s.%s", header, claim, signature);
+ status = ssnprintf(buffer, buffer_size, "%s.%s.%s", header, claim, signature);
if (status < 1)
return -1;
else if ((size_t)status >= buffer_size)
return -1;
}
- snprintf(post_data, sizeof(post_data), "grant_type=%s&assertion=%s",
+ ssnprintf(post_data, sizeof(post_data), "grant_type=%s&assertion=%s",
OAUTH_GRANT_TYPE, assertion);
curl = curl_easy_init();
char const *home;
if ((home = getenv("HOME")) != NULL) {
char path[PATH_MAX];
- snprintf(path, sizeof(path),
+ ssnprintf(path, sizeof(path),
"%s/.config/gcloud/application_default_credentials.json", home);
oauth_google_t ret = oauth_create_google_file(path, scope);
/* generate id field */
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "id");
uid = ovs_uid_generate();
- snprintf(uid_buff, sizeof(uid_buff), "%" PRIX64, uid);
+ ssnprintf(uid_buff, sizeof(uid_buff), "%" PRIX64, uid);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, uid_buff);
OVS_YAJL_CALL(yajl_gen_map_close, jgen);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, OVS_DB_DEFAULT_DB_NAME);
/* uid string <json-value> */
- snprintf(uid_str, sizeof(uid_str), "%" PRIX64, new_cb->uid);
+ ssnprintf(uid_str, sizeof(uid_str), "%" PRIX64, new_cb->uid);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, uid_str);
/* <monitor-requests> */
if (rra_num >= rra_max)
break;
- status = snprintf(buffer, sizeof(buffer), "RRA:%s:%.10f:%u:%u",
+ status = ssnprintf(buffer, sizeof(buffer), "RRA:%s:%.10f:%u:%u",
rra_types[j], cfg->xff, cdp_len, cdp_num);
if ((status < 0) || ((size_t)status >= sizeof(buffer))) {
if (isnan(d->min)) {
sstrncpy(min, "U", sizeof(min));
} else
- snprintf(min, sizeof(min), "%f", d->min);
+ ssnprintf(min, sizeof(min), "%f", d->min);
if (isnan(d->max)) {
sstrncpy(max, "U", sizeof(max));
} else
- snprintf(max, sizeof(max), "%f", d->max);
+ ssnprintf(max, sizeof(max), "%f", d->max);
- status = snprintf(
+ status = ssnprintf(
buffer, sizeof(buffer), "DS:%s:%s:%i:%s:%s", d->name, type,
(cfg->heartbeat > 0) ? cfg->heartbeat
: (int)CDTIME_T_TO_TIME_T(2 * vl->interval),
if (last_up == 0)
last_up = time(NULL) - 10;
- snprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
- snprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
+ ssnprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
+ ssnprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
new_argv[0] = "create";
new_argv[1] = (void *)filename;
return 0;
}
- snprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
+ ssnprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
status = srrd_create(tmpfile, args->pdp_step, args->last_up, args->argc,
(void *)args->argv);
if (plugin_instance == NULL)
plugin_instance = "default";
- snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
+ ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
plugin_instance, category);
sstrncpy(vl.type, type, sizeof(vl.type));
return EINVAL;
}
- snprintf(callback_name, sizeof(callback_name), "varnish/%s",
+ ssnprintf(callback_name, sizeof(callback_name), "varnish/%s",
(conf->instance == NULL) ? "localhost" : conf->instance);
plugin_register_complex_read(
const char *type) {
char type_instance[DATA_MAX_NAME_LEN];
- snprintf(type_instance, sizeof(type_instance), "%d", vcpu_nr);
+ ssnprintf(type_instance, sizeof(type_instance), "%d", vcpu_nr);
submit(dom, type, type_instance, &(value_t){.derive = value}, 1);
}
}
char flush_type_instance[DATA_MAX_NAME_LEN];
- snprintf(flush_type_instance, sizeof(flush_type_instance), "flush-%s",
+ ssnprintf(flush_type_instance, sizeof(flush_type_instance), "flush-%s",
type_instance);
if ((bstats->bi.rd_req != -1) && (bstats->bi.wr_req != -1))
const char *reason_str = "N/A";
#endif
- snprintf(msg, sizeof(msg), "Domain state: %s. Reason: %s", state_str,
+ ssnprintf(msg, sizeof(msg), "Domain state: %s. Reason: %s", state_str,
reason_str);
int severity;
char type_instance[DATA_MAX_NAME_LEN];
bool is_set = VIR_CPU_USABLE(cpu_maps, cpu_map_len, vcpu, cpu);
- snprintf(type_instance, sizeof(type_instance), "vcpu_%d-cpu_%d", vcpu, cpu);
+ ssnprintf(type_instance, sizeof(type_instance), "vcpu_%d-cpu_%d", vcpu, cpu);
submit(dom, "cpu_affinity", type_instance, &(value_t){.gauge = is_set}, 1);
}
}
memset(lv_ud, 0, sizeof(*lv_ud));
- snprintf(inst->tag, sizeof(inst->tag), "%s-%" PRIsz, PLUGIN_NAME, i);
+ ssnprintf(inst->tag, sizeof(inst->tag), "%s-%" PRIsz, PLUGIN_NAME, i);
inst->id = i;
user_data_t *ud = &(lv_ud->ud);
goto done;
}
- snprintf(xpath_str, sizeof(xpath_str), "/domain/metadata/%s:%s/text()",
+ ssnprintf(xpath_str, sizeof(xpath_str), "/domain/metadata/%s:%s/text()",
METADATA_VM_PARTITION_PREFIX, METADATA_VM_PARTITION_ELEMENT);
xpath_obj = xmlXPathEvalExpression((xmlChar *)xpath_str, xpath_ctx);
if (xpath_obj == NULL) {
break;
case if_number: {
char number_string[4];
- snprintf(number_string, sizeof(number_string), "%d", itf_number);
+ ssnprintf(number_string, sizeof(number_string), "%d", itf_number);
if (ignore_device_match(il_interface_devices, domname, number_string) !=
0)
device_ignored = true;
}
char number_string[21];
- snprintf(number_string, sizeof(number_string), "interface-%u", number);
+ ssnprintf(number_string, sizeof(number_string), "interface-%u", number);
char *number_copy = strdup(number_string);
if (!number_copy) {
sfree(path_copy);
ERROR(PLUGIN_NAME " plugin: malloc failed.");
return 0;
}
- snprintf(name, n, "%s:%s", domname, devpath);
+ ssnprintf(name, n, "%s:%s", domname, devpath);
int r = ignorelist_match(il, name);
sfree(name);
return r;
#define KAFKA_RANDOM_KEY_BUFFER \
(char[KAFKA_RANDOM_KEY_SIZE]) { "" }
static char *kafka_random_key(char buffer[static KAFKA_RANDOM_KEY_SIZE]) {
- snprintf(buffer, KAFKA_RANDOM_KEY_SIZE, "%08" PRIX32, cdrand_u());
+ ssnprintf(buffer, KAFKA_RANDOM_KEY_SIZE, "%08" PRIX32, cdrand_u());
return buffer;
}
rd_kafka_topic_conf_set_partitioner_cb(tctx->conf, kafka_partition);
rd_kafka_topic_conf_set_opaque(tctx->conf, tctx);
- snprintf(callback_name, sizeof(callback_name), "write_kafka/%s",
+ ssnprintf(callback_name, sizeof(callback_name), "write_kafka/%s",
tctx->topic_name);
status = plugin_register_write(
* know that they are sane. */
for (size_t i = 0; i < m->n_label; i++) {
char value[LABEL_VALUE_SIZE];
- snprintf(labels[i], LABEL_BUFFER_SIZE, "%s=\"%s\"", m->label[i]->name,
+ ssnprintf(labels[i], LABEL_BUFFER_SIZE, "%s=\"%s\"", m->label[i]->name,
escape_label_value(value, sizeof(value), m->label[i]->value));
}
while (c_avl_iterator_next(iter, (void *)&unused_name, (void *)&fam) == 0) {
char line[1024]; /* 4x DATA_MAX_NAME_LEN? */
- snprintf(line, sizeof(line), "# HELP %s %s\n", fam->name, fam->help);
+ ssnprintf(line, sizeof(line), "# HELP %s %s\n", fam->name, fam->help);
buffer->append(buffer, strlen(line), (uint8_t *)line);
- snprintf(line, sizeof(line), "# TYPE %s %s\n", fam->name,
+ ssnprintf(line, sizeof(line), "# TYPE %s %s\n", fam->name,
(fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__GAUGE)
? "gauge"
: "counter");
char timestamp_ms[24] = "";
if (m->has_timestamp_ms)
- snprintf(timestamp_ms, sizeof(timestamp_ms), " %" PRIi64,
+ ssnprintf(timestamp_ms, sizeof(timestamp_ms), " %" PRIi64,
m->timestamp_ms);
if (fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__GAUGE)
- snprintf(line, sizeof(line), "%s{%s} " GAUGE_FORMAT "%s\n", fam->name,
+ ssnprintf(line, sizeof(line), "%s{%s} " GAUGE_FORMAT "%s\n", fam->name,
format_labels(labels, sizeof(labels), m), m->gauge->value,
timestamp_ms);
else /* if (fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__COUNTER) */
- snprintf(line, sizeof(line), "%s{%s} %.0f%s\n", fam->name,
+ ssnprintf(line, sizeof(line), "%s{%s} %.0f%s\n", fam->name,
format_labels(labels, sizeof(labels), m), m->counter->value,
timestamp_ms);
c_avl_iterator_destroy(iter);
char server[1024];
- snprintf(server, sizeof(server), "\n# collectd/write_prometheus %s at %s\n",
+ ssnprintf(server, sizeof(server), "\n# collectd/write_prometheus %s at %s\n",
PACKAGE_VERSION, hostname_g);
buffer->append(buffer, strlen(server), (uint8_t *)server);
msg->name = name;
char help[1024];
- snprintf(
+ ssnprintf(
help, sizeof(help),
"write_prometheus plugin: '%s' Type: '%s', Dstype: '%s', Dsname: '%s'",
vl->plugin, vl->type, DS_TYPE_TO_STRING(ds->ds[ds_index].type),
static int prom_open_socket(int addrfamily) {
/* {{{ */
char service[NI_MAXSERV];
- snprintf(service, sizeof(service), "%hu", httpd_port);
+ ssnprintf(service, sizeof(service), "%hu", httpd_port);
struct addrinfo *res;
int status = getaddrinfo(httpd_host, service,
status = FORMAT_VL(ident, sizeof(ident), vl);
if (status != 0)
return status;
- snprintf(key, sizeof(key), "%s%s",
+ ssnprintf(key, sizeof(key), "%s%s",
(node->prefix != NULL) ? node->prefix : REDIS_DEFAULT_PREFIX, ident);
- snprintf(time, sizeof(time), "%.9f", CDTIME_T_TO_DOUBLE(vl->time));
+ ssnprintf(time, sizeof(time), "%.9f", CDTIME_T_TO_DOUBLE(vl->time));
value_size = sizeof(value);
value_ptr = &value[0];
if (status == 0) {
char cb_name[sizeof("write_redis/") + DATA_MAX_NAME_LEN];
- snprintf(cb_name, sizeof(cb_name), "write_redis/%s", node->name);
+ ssnprintf(cb_name, sizeof(cb_name), "write_redis/%s", node->name);
status =
plugin_register_write(cb_name, wr_write,
vl->type_instance);
if (host->always_append_ds || (ds->ds_num > 1)) {
if (host->event_service_prefix == NULL)
- snprintf(service_buffer, sizeof(service_buffer), "%s/%s", &name_buffer[1],
+ ssnprintf(service_buffer, sizeof(service_buffer), "%s/%s", &name_buffer[1],
ds->ds[index].name);
else
- snprintf(service_buffer, sizeof(service_buffer), "%s%s/%s",
+ ssnprintf(service_buffer, sizeof(service_buffer), "%s%s/%s",
host->event_service_prefix, &name_buffer[1], ds->ds[index].name);
} else {
if (host->event_service_prefix == NULL)
sstrncpy(service_buffer, &name_buffer[1], sizeof(service_buffer));
else
- snprintf(service_buffer, sizeof(service_buffer), "%s%s",
+ ssnprintf(service_buffer, sizeof(service_buffer), "%s%s",
host->event_service_prefix, &name_buffer[1]);
}
if ((ds->ds[index].type != DS_TYPE_GAUGE) && (rates != NULL)) {
char ds_type[DATA_MAX_NAME_LEN];
- snprintf(ds_type, sizeof(ds_type), "%s:rate",
+ ssnprintf(ds_type, sizeof(ds_type), "%s:rate",
DS_TYPE_TO_STRING(ds->ds[index].type));
riemann_event_string_attribute_add(event, "ds_type", ds_type);
} else {
{
char ds_index[DATA_MAX_NAME_LEN];
- snprintf(ds_index, sizeof(ds_index), "%" PRIsz, index);
+ ssnprintf(ds_index, sizeof(ds_index), "%" PRIsz, index);
riemann_event_string_attribute_add(event, "ds_index", ds_index);
}
return status;
}
- snprintf(callback_name, sizeof(callback_name), "write_riemann/%s",
+ ssnprintf(callback_name, sizeof(callback_name), "write_riemann/%s",
host->name);
user_data_t ud = {.data = host, .free_func = wrr_free};
return NULL;
}
- status = snprintf(authorization_header, sizeof(authorization_header),
+ status = ssnprintf(authorization_header, sizeof(authorization_header),
"Authorization: Bearer %s", access_token);
if ((status < 1) || ((size_t)status >= sizeof(authorization_header)))
return NULL;
if (err == NULL) {
strncpy(buffer, "Unknown error (API error is NULL)", buffer_size);
} else if (err->message == NULL) {
- snprintf(buffer, buffer_size, "API error %d", err->code);
+ ssnprintf(buffer, buffer_size, "API error %d", err->code);
} else {
- snprintf(buffer, buffer_size, "API error %d: %s", err->code, err->message);
+ ssnprintf(buffer, buffer_size, "API error %d: %s", err->code, err->message);
}
return buffer;
static int wg_call_metricdescriptor_create(wg_callback_t *cb,
char const *payload) {
char url[1024];
- snprintf(url, sizeof(url), "%s/projects/%s/metricDescriptors", cb->url,
+ ssnprintf(url, sizeof(url), "%s/projects/%s/metricDescriptors", cb->url,
cb->project);
wg_memory_t response = {0};
static int wg_call_timeseries_write(wg_callback_t *cb, char const *payload) {
char url[1024];
- snprintf(url, sizeof(url), "%s/projects/%s/timeSeries", cb->url, cb->project);
+ ssnprintf(url, sizeof(url), "%s/projects/%s/timeSeries", cb->url, cb->project);
wg_memory_t response = {0};
int status = do_post(cb, url, payload, &response);
size_t valuelen = sizeof(value);
int rv;
- snprintf(buffer, sizeof(buffer), "%s%s", zfs_arcstat, name);
+ ssnprintf(buffer, sizeof(buffer), "%s%s", zfs_arcstat, name);
rv = sysctlbyname(buffer, (void *)&value, &valuelen,
/* new value = */ NULL, /* new length = */ (size_t)0);
if (rv == 0)
projects / collectd.git / commitdiff