sstrncpy(inst->ident.plugin_instance, AGG_FUNC_PLACEHOLDER,
sizeof(inst->ident.plugin_instance));
else if (strcmp("", tmp_plugin) != 0)
- ssnprintf(inst->ident.plugin_instance,
+ snprintf(inst->ident.plugin_instance,
sizeof(inst->ident.plugin_instance), "%s-%s", tmp_plugin,
AGG_FUNC_PLACEHOLDER);
else if (strcmp("", tmp_plugin_instance) != 0)
- ssnprintf(inst->ident.plugin_instance,
+ snprintf(inst->ident.plugin_instance,
sizeof(inst->ident.plugin_instance), "%s-%s",
tmp_plugin_instance, AGG_FUNC_PLACEHOLDER);
else
- ssnprintf(inst->ident.plugin_instance,
+ snprintf(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);
- ssnprintf(buffer, buffer_size, "Server connection error %d: %s",
+ snprintf(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);
- ssnprintf(buffer, buffer_size, "Server channel error %d: %s",
+ snprintf(buffer, buffer_size, "Server channel error %d: %s",
m->reply_code, tmp);
sfree(tmp);
} else {
- ssnprintf(buffer, buffer_size, "Server error method %#" PRIx32,
+ snprintf(buffer, buffer_size, "Server error method %#" PRIx32,
r.reply.id);
}
break;
default:
- ssnprintf(buffer, buffer_size, "Unknown reply type %i", (int)r.reply_type);
+ snprintf(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 {
- ssnprintf(routing_key, sizeof(routing_key), "collectd/%s/%s/%s/%s/%s",
+ snprintf(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];
- ssnprintf(cbname, sizeof(cbname), "amqp/%s", conf->name);
+ snprintf(cbname, sizeof(cbname), "amqp/%s", conf->name);
status = plugin_register_write(
cbname, camqp_write, &(user_data_t){
if (status == 0) {
char callback_name[3 * DATA_MAX_NAME_LEN];
- ssnprintf(callback_name, sizeof(callback_name), "apache/%s/%s",
+ snprintf(callback_name, sizeof(callback_name), "apache/%s/%s",
(st->host != NULL) ? st->host : hostname_g,
(st->name != NULL) ? st->name : "default");
static char credentials[1024];
int status;
- status = ssnprintf(credentials, sizeof(credentials), "%s:%s", st->user,
+ status = snprintf(credentials, sizeof(credentials), "%s:%s", st->user,
(st->pass == NULL) ? "" : st->pass);
if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
ERROR("apache plugin: init_host: Returning an error "
static char credentials[1024];
int status;
- status = ssnprintf(credentials, sizeof(credentials), "%s:%s", user,
+ status = snprintf(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 "
char filename[PATH_MAX];
int status;
- ssnprintf(filename, sizeof(filename), "%s/%s/%s", dir, power_supply,
+ snprintf(filename, sizeof(filename), "%s/%s/%s", dir, power_supply,
basename);
status = (int)read_file_contents(filename, buffer, buffer_size - 1);
FILE *fh;
- ssnprintf(filename, sizeof(filename), "%s/%s/info", dir, power_supply);
+ snprintf(filename, sizeof(filename), "%s/%s/info", dir, power_supply);
fh = fopen(filename, "r");
if (fh == NULL)
return errno;
FILE *fh;
- ssnprintf(filename, sizeof(filename), "%s/%s/state", dir, power_supply);
+ snprintf(filename, sizeof(filename), "%s/%s/state", dir, power_supply);
fh = fopen(filename, "r");
if (fh == NULL) {
if ((errno == EAGAIN) || (errno == EINTR) || (errno == ENOENT))
gauge_t voltage = NAN;
gauge_t charge = NAN;
- ssnprintf(filename, sizeof(filename), PROC_PMU_PATH_FORMAT, i);
+ snprintf(filename, sizeof(filename), PROC_PMU_PATH_FORMAT, i);
if (access(filename, R_OK) != 0)
break;
- ssnprintf(plugin_instance, sizeof(plugin_instance), "%i", i);
+ snprintf(plugin_instance, sizeof(plugin_instance), "%i", i);
fh = fopen(filename, "r");
if (fh == NULL) {
nsstats_translation_table_length,
plugin_instance};
- ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-zone-%s",
+ snprintf(plugin_instance, sizeof(plugin_instance), "%s-zone-%s",
view->name, zone_name);
if (version == 3) {
list_info_ptr_t list_info = {plugin_instance,
/* type = */ "dns_qtype"};
- ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-qtypes",
+ snprintf(plugin_instance, sizeof(plugin_instance), "%s-qtypes",
view->name);
if (version == 3) {
bind_parse_generic_name_attr_value_list(
resstats_translation_table_length,
plugin_instance};
- ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-resolver_stats",
+ snprintf(plugin_instance, sizeof(plugin_instance), "%s-resolver_stats",
view->name);
if (version == 3) {
bind_parse_generic_name_attr_value_list(
list_info_ptr_t list_info = {plugin_instance,
/* type = */ "dns_qtype_cached"};
- ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-cache_rr_sets",
+ snprintf(plugin_instance, sizeof(plugin_instance), "%s-cache_rr_sets",
view->name);
bind_parse_generic_name_value(/* xpath = */ "cache/rrset",
if (ignorelist_match(il_cgroup, cgroup_name))
return 0;
- ssnprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, cgroup_name);
+ snprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, cgroup_name);
status = lstat(abs_path, &statbuf);
if (status != 0) {
if (!S_ISDIR(statbuf.st_mode))
return 0;
- ssnprintf(abs_path, sizeof(abs_path), "%s/%s/cpuacct.stat", dirname,
+ snprintf(abs_path, sizeof(abs_path), "%s/%s/cpuacct.stat", dirname,
cgroup_name);
fh = fopen(abs_path, "r");
if (fh == NULL) {
struct stat statbuf;
int status;
- ssnprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, filename);
+ snprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, filename);
status = lstat(abs_path, &statbuf);
if (status != 0) {
sizeof(vl.type_instance));
if (cpu_num >= 0) {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
}
plugin_dispatch_values(&vl);
}
num_cpu = 0;
while (1) {
- status = ssnprintf(filename, sizeof(filename),
+ status = snprintf(filename, sizeof(filename),
"/sys/devices/system/cpu/cpu%d/cpufreq/"
"scaling_cur_freq",
num_cpu);
vl.values_len = 1;
sstrncpy(vl.plugin, "cpufreq", sizeof(vl.plugin));
sstrncpy(vl.type, "cpufreq", sizeof(vl.type));
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i", cpu_num);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%i", cpu_num);
plugin_dispatch_values(&vl);
}
static int cpufreq_read(void) {
for (int i = 0; i < num_cpu; i++) {
char filename[PATH_MAX];
- ssnprintf(filename, sizeof(filename),
+ snprintf(filename, sizeof(filename),
"/sys/devices/system/cpu/cpu%d/cpufreq/scaling_cur_freq", i);
value_t v;
memset(buffer, '\0', buffer_len);
- status = ssnprintf(buffer, buffer_len, "%.3f", CDTIME_T_TO_DOUBLE(vl->time));
+ status = snprintf(buffer, buffer_len, "%.3f", CDTIME_T_TO_DOUBLE(vl->time));
if ((status < 1) || (status >= buffer_len))
return -1;
offset = status;
}
if (ds->ds[i].type == DS_TYPE_GAUGE) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ",%lf",
+ status = snprintf(buffer + offset, buffer_len - offset, ",%lf",
vl->values[i].gauge);
} else if (store_rates != 0) {
if (rates == NULL)
return -1;
}
status =
- ssnprintf(buffer + offset, buffer_len - offset, ",%lf", rates[i]);
+ snprintf(buffer + offset, buffer_len - offset, ",%lf", rates[i]);
} else if (ds->ds[i].type == DS_TYPE_COUNTER) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ",%llu",
+ status = snprintf(buffer + offset, buffer_len - offset, ",%llu",
vl->values[i].counter);
} else if (ds->ds[i].type == DS_TYPE_DERIVE) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ",%" PRIi64,
+ status = snprintf(buffer + offset, buffer_len - offset, ",%" PRIi64,
vl->values[i].derive);
} else if (ds->ds[i].type == DS_TYPE_ABSOLUTE) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ",%" PRIu64,
+ status = snprintf(buffer + offset, buffer_len - offset, ",%" PRIu64,
vl->values[i].absolute);
}
return -1;
}
- ssnprintf(wp->credentials, credentials_size, "%s:%s", wp->user,
+ snprintf(wp->credentials, credentials_size, "%s:%s", wp->user,
(wp->pass == NULL) ? "" : wp->pass);
curl_easy_setopt(wp->curl, CURLOPT_USERPWD, wp->credentials);
#endif
db->state[db->depth].index++;
char name[DATA_MAX_NAME_LEN];
- ssnprintf(name, sizeof(name), "%d", db->state[db->depth].index);
+ snprintf(name, sizeof(name), "%d", db->state[db->depth].index);
cj_load_key(db, name);
}
return -1;
}
- ssnprintf(db->credentials, credentials_size, "%s:%s", db->user,
+ snprintf(db->credentials, credentials_size, "%s:%s", db->user,
(db->pass == NULL) ? "" : db->pass);
curl_easy_setopt(db->curl, CURLOPT_USERPWD, db->credentials);
#endif
if (key->instance == NULL) {
int len = 0;
for (int i = 0; i < db->depth; i++)
- len += ssnprintf(vl.type_instance + len, sizeof(vl.type_instance) - len,
+ len += snprintf(vl.type_instance + len, sizeof(vl.type_instance) - len,
i ? "-%s" : "%s", db->state[i + 1].name);
} else
sstrncpy(vl.type_instance, key->instance, sizeof(vl.type_instance));
if (xpath->instance_prefix != NULL) {
if (instance_node != NULL) {
char *node_value = (char *)xmlNodeGetContent(instance_node->nodeTab[0]);
- ssnprintf(vl->type_instance, sizeof(vl->type_instance), "%s%s",
+ snprintf(vl->type_instance, sizeof(vl->type_instance), "%s%s",
xpath->instance_prefix, node_value);
sfree(node_value);
} else
return -1;
}
- ssnprintf(db->credentials, credentials_size, "%s:%s", db->user,
+ snprintf(db->credentials, credentials_size, "%s:%s", db->user,
(db->pass == NULL) ? "" : db->pass);
curl_easy_setopt(db->curl, CURLOPT_USERPWD, db->credentials);
#endif
return dest;
} /* char *sstrncpy */
-int ssnprintf(char *dest, size_t n, const char *format, ...) {
- int ret = 0;
- va_list ap;
-
- va_start(ap, format);
- ret = vsnprintf(dest, n, format, ap);
- dest[n - 1] = '\0';
- va_end(ap);
-
- return ret;
-} /* int ssnprintf */
-
char *ssnprintf_alloc(char const *format, ...) /* {{{ */
{
char static_buffer[1024] = "";
#else
if (strerror_r(errnum, buf, buflen) != 0) {
- ssnprintf(buf, buflen, "Error #%i; "
+ snprintf(buf, buflen, "Error #%i; "
"Additionally, strerror_r failed.",
errnum);
}
if (kc == NULL)
return -1;
- ssnprintf(ident, sizeof(ident), "%s,%i,%s", module, instance, name);
+ snprintf(ident, sizeof(ident), "%s,%i,%s", module, instance, name);
*ksp_ptr = kstat_lookup(kc, module, instance, name);
if (*ksp_ptr == NULL) {
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
+ status = snprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
return -1; \
char *sstrncpy(char *dest, const char *src, size_t n);
-__attribute__((format(printf, 3, 4))) int ssnprintf(char *dest, size_t n,
- const char *format, ...);
-
__attribute__((format(printf, 1, 2))) char *ssnprintf_alloc(char const *format,
...);
return 0;
}
-DEF_TEST(ssnprintf) {
- char buffer[16] = "";
- char *ptr = &buffer[4];
- int status;
-
- buffer[0] = buffer[1] = buffer[2] = buffer[3] = 0xff;
- buffer[12] = buffer[13] = buffer[14] = buffer[15] = 0xff;
-
- status = ssnprintf(ptr, 8, "%i", 1337);
- OK(status == 4);
- EXPECT_EQ_STR("1337", ptr);
-
- status = ssnprintf(ptr, 8, "%s", "collectd");
- OK(status == 8);
- OK(ptr[7] == 0);
- EXPECT_EQ_STR("collect", ptr);
- OK(buffer[3] == buffer[12]);
-
- return 0;
-}
-
DEF_TEST(sstrdup) {
char *ptr;
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);
+ snprintf(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 =
- ssnprintf(buffer_ptr, buffer_free, " %s", ci->values[i].value.string);
+ snprintf(buffer_ptr, buffer_free, " %s", ci->values[i].value.string);
else if (ci->values[i].type == OCONFIG_TYPE_NUMBER)
- status = ssnprintf(buffer_ptr, buffer_free, " %lf",
+ status = snprintf(buffer_ptr, buffer_free, " %lf",
ci->values[i].value.number);
else if (ci->values[i].type == OCONFIG_TYPE_BOOLEAN)
- status = ssnprintf(buffer_ptr, buffer_free, " %s",
+ status = snprintf(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 = ssnprintf(name, sizeof(name), "%s/%s", dir, de->d_name);
+ status = snprintf(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.",
ERROR("cf_util_get_service: Out of memory.");
return -1;
}
- ssnprintf(service, 6, "%i", port);
+ snprintf(service, 6, "%i", port);
sfree(*ret_string);
*ret_string = service;
if (ci->values_num == 1) {
sstrncpy(rule->name, ci->values[0].value.string, sizeof(rule->name));
- ssnprintf(rule_name, sizeof(rule_name), "Rule \"%s\"",
+ snprintf(rule_name, sizeof(rule_name), "Rule \"%s\"",
ci->values[0].value.string);
}
actual = e->value.mv_string;
break;
case MD_TYPE_SIGNED_INT:
- ssnprintf(buffer, sizeof(buffer), "%" PRIi64, e->value.mv_signed_int);
+ snprintf(buffer, sizeof(buffer), "%" PRIi64, e->value.mv_signed_int);
actual = buffer;
break;
case MD_TYPE_UNSIGNED_INT:
- ssnprintf(buffer, sizeof(buffer), "%" PRIu64, e->value.mv_unsigned_int);
+ snprintf(buffer, sizeof(buffer), "%" PRIu64, e->value.mv_unsigned_int);
actual = buffer;
break;
case MD_TYPE_DOUBLE:
- ssnprintf(buffer, sizeof(buffer), GAUGE_FORMAT, e->value.mv_double);
+ snprintf(buffer, sizeof(buffer), GAUGE_FORMAT, e->value.mv_double);
actual = buffer;
break;
case MD_TYPE_BOOLEAN:
if (dlh == NULL) {
char errbuf[1024] = "";
- ssnprintf(errbuf, sizeof(errbuf),
+ snprintf(errbuf, sizeof(errbuf),
"dlopen (\"%s\") failed: %s. "
"The most common cause for this problem is "
"missing dependencies. Use ldd(1) to check "
}
char name[THREAD_NAME_MAX];
- ssnprintf(name, sizeof(name), "reader#%zu", read_threads_num);
+ snprintf(name, sizeof(name), "reader#%zu", read_threads_num);
set_thread_name(read_threads[read_threads_num], name);
read_threads_num++;
}
char name[THREAD_NAME_MAX];
- ssnprintf(name, sizeof(name), "writer#%zu", write_threads_num);
+ snprintf(name, sizeof(name), "writer#%zu", write_threads_num);
set_thread_name(write_threads[write_threads_num], name);
write_threads_num++;
/* `cpu' should not match `cpufreq'. To solve this we add `.so' to the
* type when matching the filename */
- status = ssnprintf(typename, sizeof(typename), "%s.so", plugin_name);
+ status = snprintf(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;
if (strcasecmp(de->d_name, typename))
continue;
- status = ssnprintf(filename, sizeof(filename), "%s/%s", dir, de->d_name);
+ status = snprintf(filename, sizeof(filename), "%s/%s", dir, de->d_name);
if ((status < 0) || ((size_t)status >= sizeof(filename))) {
WARNING("plugin_load: Filename too long: \"%s/%s\"", dir, de->d_name);
continue;
size_left -= len;
if (print_nano) {
- if ((len = ssnprintf(pos, size_left, ".%09ld", nsec)) == 0)
+ if ((len = snprintf(pos, size_left, ".%09ld", nsec)) == 0)
return ENOMEM;
pos += len;
size_left -= len;
msg = NULL;
status = dbi_conn_error(conn, &msg);
if ((status >= 0) && (msg != NULL))
- ssnprintf(buffer, buffer_size, "%s (status %i)", msg, status);
+ snprintf(buffer, buffer_size, "%s (status %i)", msg, status);
else
- ssnprintf(buffer, buffer_size, "dbi_conn_error failed with status %i",
+ snprintf(buffer, buffer_size, "dbi_conn_error failed with status %i",
status);
return buffer;
long long value;
value = dbi_result_get_longlong_idx(res, index);
- ssnprintf(buffer, buffer_size, "%lli", value);
+ snprintf(buffer, buffer_size, "%lli", value);
} else if (src_type == DBI_TYPE_DECIMAL) {
double value;
value = dbi_result_get_double_idx(res, index);
- ssnprintf(buffer, buffer_size, "%63.15g", value);
+ snprintf(buffer, buffer_size, "%63.15g", value);
} else if (src_type == DBI_TYPE_STRING) {
const char *value;
sstrncpy(disk_name, props_disk_name_bsd, sizeof(disk_name));
else {
ERROR("disk plugin: can't find bsd disk name.");
- ssnprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major,
+ snprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major,
disk_minor);
}
} else
- ssnprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major, disk_minor);
+ snprintf(disk_name, sizeof(disk_name), "%i-%i", disk_major, disk_minor);
DEBUG("disk plugin: disk_name = \"%s\"", disk_name);
if (strcasecmp("PortName", child->key) == 0) {
while (!(ec->config.link_status.enabled_port_mask & (1 << port_num)))
port_num++;
- ssnprintf(ec->config.link_status.port_name[port_num], DATA_MAX_NAME_LEN,
+ snprintf(ec->config.link_status.port_name[port_num], DATA_MAX_NAME_LEN,
"%s", child->values[0].value.string);
DEBUG(DPDK_EVENTS_PLUGIN ": LinkStatus:Port %d Name: %s", port_num,
ec->config.link_status.port_name[port_num]);
(int)child->values[0].value.boolean);
} else if (strcasecmp("LCoreMask", child->key) == 0) {
char lcore_mask[DATA_MAX_NAME_LEN];
- ssnprintf(lcore_mask, sizeof(lcore_mask), "%s",
+ snprintf(lcore_mask, sizeof(lcore_mask), "%s",
child->values[0].value.string);
ec->config.keep_alive.lcore_mask =
str_to_uint128(lcore_mask, strlen(lcore_mask));
ec->config.keep_alive.lcore_mask.high,
ec->config.keep_alive.lcore_mask.low);
} else if (strcasecmp("KeepAliveShmName", child->key) == 0) {
- ssnprintf(ec->config.keep_alive.shm_name,
+ snprintf(ec->config.keep_alive.shm_name,
sizeof(ec->config.keep_alive.shm_name), "%s",
child->values[0].value.string);
DEBUG(DPDK_EVENTS_PLUGIN ": KeepAlive:KeepAliveShmName %s",
char dev_name[DATA_MAX_NAME_LEN];
if (ec->config.link_status.port_name[i][0] != 0) {
- ssnprintf(dev_name, sizeof(dev_name), "%s",
+ snprintf(dev_name, sizeof(dev_name), "%s",
ec->config.link_status.port_name[i]);
} else {
- ssnprintf(dev_name, sizeof(dev_name), "port.%d", i);
+ snprintf(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];
- ssnprintf(msg, sizeof(msg), "Link Status: %s",
+ snprintf(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];
- ssnprintf(core_name, sizeof(core_name), "lcore%u", i);
+ snprintf(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;
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: ALIVE", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: ALIVE", i);
break;
case RTE_KA_STATE_MISSING:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: MISSING", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: MISSING", i);
sev = NOTIF_WARNING;
break;
case RTE_KA_STATE_DEAD:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DEAD", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DEAD", i);
sev = NOTIF_FAILURE;
break;
case RTE_KA_STATE_UNUSED:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNUSED", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNUSED", i);
sev = NOTIF_OKAY;
break;
case RTE_KA_STATE_GONE:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: GONE", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: GONE", i);
sev = NOTIF_FAILURE;
break;
case RTE_KA_STATE_DOZING:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DOZING", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: DOZING", i);
sev = NOTIF_OKAY;
break;
case RTE_KA_STATE_SLEEP:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: SLEEP", i);
+ snprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: SLEEP", i);
sev = NOTIF_OKAY;
break;
default:
- ssnprintf(msg, sizeof(msg), "lcore %u Keep Alive Status: UNKNOWN", i);
+ snprintf(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) {
- ssnprintf(dev_name, sizeof(dev_name), "%s", ctx->config.port_name[i]);
+ snprintf(dev_name, sizeof(dev_name), "%s", ctx->config.port_name[i]);
} else {
- ssnprintf(dev_name, sizeof(dev_name), "port.%d", i);
+ snprintf(dev_name, sizeof(dev_name), "port.%d", i);
}
DEBUG(" === Dispatch stats for port %d (name=%s; stats_count=%d)", i,
return EINVAL;
}
- ssnprintf(plugin_instance, sizeof(plugin_instance), "r%ld", resource);
+ snprintf(plugin_instance, sizeof(plugin_instance), "r%ld", resource);
for (size_t i = 0; i < drbd_names_num; i++) {
char *data;
pl->argv[i] = strdup(ci->values[i + 1].value.string);
} else {
if (ci->values[i + 1].type == OCONFIG_TYPE_NUMBER) {
- ssnprintf(buffer, sizeof(buffer), "%lf",
+ snprintf(buffer, sizeof(buffer), "%lf",
ci->values[i + 1].value.number);
} else {
if (ci->values[i + 1].value.boolean)
char buffer[1024];
#ifdef HAVE_SETENV
- ssnprintf(buffer, sizeof(buffer), "%.3f",
+ snprintf(buffer, sizeof(buffer), "%.3f",
CDTIME_T_TO_DOUBLE(plugin_get_interval()));
setenv("COLLECTD_INTERVAL", buffer, /* overwrite = */ 1);
sstrncpy(buffer, hostname_g, sizeof(buffer));
setenv("COLLECTD_HOSTNAME", buffer, /* overwrite = */ 1);
#else
- ssnprintf(buffer, sizeof(buffer), "COLLECTD_INTERVAL=%.3f",
+ snprintf(buffer, sizeof(buffer), "COLLECTD_INTERVAL=%.3f",
CDTIME_T_TO_DOUBLE(plugin_get_interval()));
putenv(buffer);
- ssnprintf(buffer, sizeof(buffer), "COLLECTD_HOSTNAME=%s", hostname_g);
+ snprintf(buffer, sizeof(buffer), "COLLECTD_HOSTNAME=%s", hostname_g);
putenv(buffer);
#endif
} /* }}} void set_environment */
if (dir == NULL)
return -1;
- ssnprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, filename);
+ snprintf(abs_path, sizeof(abs_path), "%s/%s", dirname, filename);
status = lstat(abs_path, &statbuf);
if (status != 0) {
if (staging_tree == NULL)
return NULL;
- ssnprintf(key, sizeof(key), "%s/%s/%s", host, type,
+ snprintf(key, sizeof(key), "%s/%s/%s", host, type,
(type_instance != NULL) ? type_instance : "");
se = NULL;
} else if (strcasecmp(key, "Port") == 0) {
int port = (int)(atof(value));
if ((port > 0) && (port <= 65535))
- ssnprintf(hddtemp_port, sizeof(hddtemp_port), "%i", port);
+ snprintf(hddtemp_port, sizeof(hddtemp_port), "%i", port);
else
sstrncpy(hddtemp_port, value, sizeof(hddtemp_port));
} else {
sstrncpy(vl.plugin, g_plugin_name, sizeof(vl.plugin));
if (info->node) {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%zuKb",
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%zuKb",
info->node, info->page_size_kb);
} else {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%zuKb",
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%zuKb",
info->page_size_kb);
}
struct entry_info *info = e_info;
double value;
- ssnprintf(path2, sizeof(path2), "%s/%s", path, entry);
+ snprintf(path2, sizeof(path2), "%s/%s", path, entry);
FILE *fh = fopen(path2, "rt");
if (fh == NULL) {
}
/* /sys/devices/system/node/node?/hugepages/ */
- ssnprintf(path2, sizeof(path2), "%s/%s", path, result->d_name);
+ snprintf(path2, sizeof(path2), "%s/%s", path, result->d_name);
walk_directory(path2, read_hugepage_entry,
&(struct entry_info){
continue;
}
- ssnprintf(path, sizeof(path), sys_node_hugepages, result->d_name);
+ snprintf(path, sizeof(path), sys_node_hugepages, result->d_name);
read_syshugepages(path, result->d_name);
errno = 0;
}
char desc[DATA_MAX_NAME_LEN];
uint64_t core = i;
- ssnprintf(desc, sizeof(desc), "%d", g_rdt->pqos_cpu->cores[i].lcore);
+ snprintf(desc, sizeof(desc), "%d", g_rdt->pqos_cpu->cores[i].lcore);
/* set core group info */
ret = cgroup_set(&g_rdt->cgroups[i], desc, &core, 1);
continue;
if (unique_name)
- ssnprintf(iname, sizeof(iname), "%s_%d_%s", ksp[i]->ks_module,
+ snprintf(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) {
- ssnprintf(errbuf, sizeof(errbuf), "Unknown error %#x", status);
+ snprintf(errbuf, sizeof(errbuf), "Unknown error %#x", status);
}
errbuf[sizeof(errbuf) - 1] = 0;
sstrncpy(n.type_instance, list_item->sensor_name,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- ssnprintf(n.message, sizeof(n.message), "sensor %s not present",
+ snprintf(n.message, sizeof(n.message), "sensor %s not present",
list_item->sensor_name);
plugin_dispatch_notification(&n);
sstrncpy(n.type_instance, list_item->sensor_name,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- ssnprintf(n.message, sizeof(n.message), "sensor %s present",
+ snprintf(n.message, sizeof(n.message), "sensor %s present",
list_item->sensor_name);
plugin_dispatch_notification(&n);
if (entity_id_string == NULL)
sstrncpy(sensor_name, buffer, sizeof(sensor_name));
else
- ssnprintf(sensor_name, sizeof(sensor_name), "%s %s", buffer,
+ snprintf(sensor_name, sizeof(sensor_name), "%s %s", buffer,
entity_id_string);
sstrncpy(buffer, sensor_name, sizeof(buffer));
sensor_id_ptr = strstr(buffer, "(");
if (sensor_id_ptr != NULL) {
/* `sensor_id_ptr' now points to "(123)". */
- ssnprintf(sensor_name, sizeof(sensor_name), "%s %s", sensor_name_ptr,
+ snprintf(sensor_name, sizeof(sensor_name), "%s %s", sensor_name_ptr,
sensor_id_ptr);
}
/* else: don't touch sensor_name. */
sstrncpy(n.host, hostname_g, sizeof(n.host));
sstrncpy(n.type_instance, list_item->sensor_name, sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- ssnprintf(n.message, sizeof(n.message), "sensor %s added",
+ snprintf(n.message, sizeof(n.message), "sensor %s added",
list_item->sensor_name);
plugin_dispatch_notification(&n);
sstrncpy(n.host, hostname_g, sizeof(n.host));
sstrncpy(n.type_instance, list_item->sensor_name, sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
- ssnprintf(n.message, sizeof(n.message), "sensor %s removed",
+ snprintf(n.message, sizeof(n.message), "sensor %s removed",
list_item->sensor_name);
plugin_dispatch_notification(&n);
sstrncpy(vl.plugin, "ip6tables", sizeof(vl.plugin));
- status = ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
+ status = snprintf(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)
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
+ snprintf(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 = ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
+ status = snprintf(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)
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
chain->rule.num);
else
sstrncpy(vl.type_instance, (char *)match->data, sizeof(vl.type_instance));
struct in_addr addr = {.s_addr = se->addr};
int len =
- ssnprintf(pi, size, "%s_%s%u", inet_ntoa(addr),
+ snprintf(pi, size, "%s_%s%u", inet_ntoa(addr),
(se->protocol == IPPROTO_TCP) ? "TCP" : "UDP", ntohs(se->port));
if ((len < 0) || (size <= ((size_t)len))) {
struct in_addr addr = {.s_addr = de->addr};
- int len = ssnprintf(ti, size, "%s_%u", inet_ntoa(addr), ntohs(de->port));
+ int len = snprintf(ti, size, "%s_%u", inet_ntoa(addr), ntohs(de->port));
if ((len < 0) || (size <= ((size_t)len))) {
log_err("type instance truncated: %s", ti);
int buf_len = sizeof(buf);
int status;
- status = ssnprintf(
+ status = snprintf(
buf_ptr, buf_len, "Notification: severity = %s",
(n->severity == NOTIF_FAILURE)
? "FAILURE"
#define APPEND(bufptr, buflen, key, value) \
if ((buflen > 0) && (strlen(value) > 0)) { \
- status = ssnprintf(bufptr, buflen, ", %s = %s", key, value); \
+ status = snprintf(bufptr, buflen, ", %s = %s", key, value); \
if (status > 0) { \
bufptr += status; \
buflen -= status; \
if (pool_busy_cpus < 0.0)
pool_busy_cpus = 0.0;
- ssnprintf(typinst, sizeof(typinst), "pool-%X-busy", lparstats.pool_id);
+ snprintf(typinst, sizeof(typinst), "pool-%X-busy", lparstats.pool_id);
lpar_submit(typinst, pool_busy_cpus);
- ssnprintf(typinst, sizeof(typinst), "pool-%X-idle", lparstats.pool_id);
+ snprintf(typinst, sizeof(typinst), "pool-%X-idle", lparstats.pool_id);
lpar_submit(typinst, pool_idle_cpus);
}
luaL_checktype(L, 1, LUA_TFUNCTION);
char function_name[DATA_MAX_NAME_LEN];
- ssnprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
+ snprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
int callback_id = clua_store_callback(L, 1);
if (callback_id < 0)
luaL_checktype(L, 1, LUA_TFUNCTION);
char function_name[DATA_MAX_NAME_LEN] = "";
- ssnprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
+ snprintf(function_name, sizeof(function_name), "lua/%s", lua_tostring(L, 1));
int callback_id = clua_store_callback(L, 1);
if (callback_id < 0)
if (base_path[0] == '\0')
sstrncpy(abs_path, rel_path, sizeof(abs_path));
else
- ssnprintf(abs_path, sizeof(abs_path), "%s/%s", base_path, rel_path);
+ snprintf(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);
- ssnprintf(plugin_instance, sizeof(plugin_instance), "%s-%s", vg_name,
+ snprintf(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);
sstrncpy(vl.type, type, sizeof(vl.type));
if ((ti1 != NULL) && (ti2 != NULL))
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s", ti1, ti2);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s", ti1, ti2);
else if ((ti1 != NULL) && (ti2 == NULL))
sstrncpy(vl.type_instance, ti1, sizeof(vl.type_instance));
if (vals[i] == 0)
continue;
- ssnprintf(ti2, sizeof(ti2), "%i", i);
+ snprintf(ti2, sizeof(ti2), "%i", i);
submit_derive(dev, "ath_stat", name, ti2, (derive_t)vals[i]);
}
}
static inline void macaddr_to_str(char *buf, size_t bufsize,
const uint8_t mac[IEEE80211_ADDR_LEN]) {
- ssnprintf(buf, bufsize, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1],
+ snprintf(buf, bufsize, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1],
mac[2], mac[3], mac[4], mac[5]);
}
if (dev[0] == '.')
return 0;
- ssnprintf(buf, sizeof(buf), "/sys/class/net/%s/device/driver", dev);
+ snprintf(buf, sizeof(buf), "/sys/class/net/%s/device/driver", dev);
buf[sizeof(buf) - 1] = '\0';
i = readlink(buf, buf2, sizeof(buf2) - 1);
llist_append(*meta, entry);
}
- ssnprintf(buffer, sizeof(buffer), "%s `%s'", ci->key, meta_key);
+ snprintf(buffer, sizeof(buffer), "%s `%s'", ci->key, meta_key);
/* Can't pass &entry->value into mr_add_regex, so copy in/out. */
re_head = entry->value;
status = mr_add_regex(&re_head, ci->values[1].value.string, buffer);
.type_instance = "corrected_memory_errors"};
if (mr->dimm_name[0] != '\0')
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s_%s",
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s_%s",
mr->location, mr->dimm_name);
else
sstrncpy(vl.plugin_instance, mr->location, sizeof(vl.plugin_instance));
plugin_dispatch_values(&vl);
- ssnprintf(vl.type_instance, sizeof(vl.type_instance),
+ snprintf(vl.type_instance, sizeof(vl.type_instance),
"corrected_memory_errors_in_%s", mr->corrected_err_timed_period);
vl.values = &(value_t){.derive = (derive_t)mr->corrected_err_timed};
plugin_dispatch_values(&vl);
vl.values = &(value_t){.derive = (derive_t)mr->uncorrected_err_total};
plugin_dispatch_values(&vl);
- ssnprintf(vl.type_instance, sizeof(vl.type_instance),
+ snprintf(vl.type_instance, sizeof(vl.type_instance),
"uncorrected_memory_errors_in_%s",
mr->uncorrected_err_timed_period);
vl.values = &(value_t){.derive = (derive_t)mr->uncorrected_err_timed};
vl.values = &(value_t){.gauge = value};
vl.values_len = 1;
sstrncpy(vl.plugin, "md", sizeof(vl.plugin));
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", minor);
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", minor);
sstrncpy(vl.type, "md_disks", sizeof(vl.type));
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
* major/minor, but that again can be tricky if the filesystem
* with the device file is mounted using the "nodev" option.
*/
- ssnprintf(path, sizeof(path), "%s/%s", DEV_DIR, name);
+ snprintf(path, sizeof(path), "%s/%s", DEV_DIR, name);
md_process(minor, path);
}
char callback_name[3 * DATA_MAX_NAME_LEN];
int status;
- ssnprintf(callback_name, sizeof(callback_name), "memcached/%s",
+ snprintf(callback_name, sizeof(callback_name), "memcached/%s",
(st->name != NULL) ? st->name : "__legacy__");
/* If no <Address> used then:
vl.values_len = 1;
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ snprintf(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));
strncpy(vl.host, hostname_g, sizeof(vl.host));
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ snprintf(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.host, hostname_g, sizeof(vl.host));
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
if (core < 0) /* global aggregation */
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
else /* per-core statistics */
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i-cpu-%i",
+ snprintf(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));
strncpy(vl.host, hostname_g, sizeof(vl.host));
strncpy(vl.plugin, "mic", sizeof(vl.plugin));
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", micnumber);
+ snprintf(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));
host->interval = plugin_get_interval();
if (slave->instance[0] == 0)
- ssnprintf(slave->instance, sizeof(slave->instance), "slave_%i", slave->id);
+ snprintf(slave->instance, sizeof(slave->instance), "slave_%i", slave->id);
vl.values = &value;
vl.values_len = 1;
if (status == 0) {
char name[1024];
- ssnprintf(name, sizeof(name), "modbus-%s", host->host);
+ snprintf(name, sizeof(name), "modbus-%s", host->host);
plugin_register_complex_read(/* group = */ NULL, name,
/* callback = */ mb_read,
if (status != 0)
return status;
- status = ssnprintf(buf, buf_len, "%s/%s", conf->topic_prefix, name);
+ status = snprintf(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);
}
- ssnprintf(cb_name, sizeof(cb_name), "mqtt/%s", conf->name);
+ snprintf(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)
- ssnprintf(cb_name, sizeof(cb_name), "mysql-%s", db->instance);
+ snprintf(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;
- ssnprintf(n.message, sizeof(n.message),
+ snprintf(n.message, sizeof(n.message),
"slave I/O thread not started or not connected to master");
plugin_dispatch_notification(&n);
db->slave_io_running = 0;
} else if (((io != NULL) && (strcasecmp(io, "yes") == 0)) &&
(!db->slave_io_running)) {
n.severity = NOTIF_OKAY;
- ssnprintf(n.message, sizeof(n.message),
+ snprintf(n.message, sizeof(n.message),
"slave I/O thread started and connected to master");
plugin_dispatch_notification(&n);
db->slave_io_running = 1;
if (((sql == NULL) || (strcasecmp(sql, "yes") != 0)) &&
(db->slave_sql_running)) {
n.severity = NOTIF_WARNING;
- ssnprintf(n.message, sizeof(n.message), "slave SQL thread not started");
+ snprintf(n.message, sizeof(n.message), "slave SQL thread not started");
plugin_dispatch_notification(&n);
db->slave_sql_running = 0;
} else if (((sql != NULL) && (strcasecmp(sql, "yes") == 0)) &&
(!db->slave_sql_running)) {
n.severity = NOTIF_OKAY;
- ssnprintf(n.message, sizeof(n.message), "slave SQL thread started");
+ snprintf(n.message, sizeof(n.message), "slave SQL thread started");
plugin_dispatch_notification(&n);
db->slave_sql_running = 1;
}
if ((hostname == NULL) || (old_data == NULL) || (new_data == NULL))
return -1;
- ssnprintf(plugin_instance, sizeof(plugin_instance), "volume-%s",
+ snprintf(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;
- ssnprintf(plugin_instance, sizeof(plugin_instance), "volume-%s", v->name);
+ snprintf(plugin_instance, sizeof(plugin_instance), "volume-%s", v->name);
if (HAS_ALL_FLAGS(v->flags, HAVE_VOLUME_USAGE_SNAP_USED |
HAVE_VOLUME_USAGE_SNAP_RSVD)) {
if ((v->flags & IS_VOLUME_USAGE_OFFLINE) != 0) {
n.severity = NOTIF_OKAY;
- ssnprintf(n.message, sizeof(n.message), "Volume %s is now online.",
+ snprintf(n.message, sizeof(n.message), "Volume %s is now online.",
v->name);
v->flags &= ~IS_VOLUME_USAGE_OFFLINE;
} else {
n.severity = NOTIF_WARNING;
- ssnprintf(n.message, sizeof(n.message), "Volume %s is now offline.",
+ snprintf(n.message, sizeof(n.message), "Volume %s is now offline.",
v->name);
v->flags |= IS_VOLUME_USAGE_OFFLINE;
}
if (volume_name == NULL)
continue;
- ssnprintf(plugin_instance, sizeof(plugin_instance), "quota-%s-%s",
+ snprintf(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 */
- ssnprintf(plugin_instance, sizeof(plugin_instance), "snapvault-%s",
+ snprintf(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)
- ssnprintf(cb_name, sizeof(cb_name), "netapp-%s-%s", host->name,
+ snprintf(cb_name, sizeof(cb_name), "netapp-%s-%s", host->name,
host->vfiler);
else
- ssnprintf(cb_name, sizeof(cb_name), "netapp-%s", host->name);
+ snprintf(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;
- ssnprintf(tc_inst, sizeof(tc_inst), "%s-%x:%x", kind, numberic_id >> 16,
+ snprintf(tc_inst, sizeof(tc_inst), "%s-%x:%x", kind, numberic_id >> 16,
numberic_id & 0x0000FFFF);
}
stats_submitted = 1;
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
+ snprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
tc_inst);
if (q_stats.bs != NULL) {
if (!stats_submitted && ts != NULL) {
char type_instance[DATA_MAX_NAME_LEN];
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
+ snprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type,
tc_inst);
submit_one(dev, "ipt_bytes", type_instance, ts->bytes);
char plugin_instance[DATA_MAX_NAME_LEN];
value_t values[fields_num];
- ssnprintf(plugin_instance, sizeof(plugin_instance), "v%i%s", nfs_version,
+ snprintf(plugin_instance, sizeof(plugin_instance), "v%i%s", nfs_version,
instance);
for (size_t i = 0; i < fields_num; i++)
if (ksp == NULL)
return EINVAL;
- ssnprintf(plugin_instance, sizeof(plugin_instance), "v%i%s", nfs_version,
+ snprintf(plugin_instance, sizeof(plugin_instance), "v%i%s", nfs_version,
inst);
kstat_read(kc, ksp, NULL);
curl_easy_setopt(curl, CURLOPT_PASSWORD, (pass == NULL) ? "" : pass);
#else
static char credentials[1024];
- int status = ssnprintf(credentials, sizeof(credentials), "%s:%s", user,
+ int status = snprintf(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;
}
- ssnprintf(summary, sizeof(summary), "collectd %s notification",
+ snprintf(summary, sizeof(summary), "collectd %s notification",
(NOTIF_FAILURE == n->severity)
? "FAILURE"
: (NOTIF_WARNING == n->severity)
static int notify_email_init(void) {
char server[MAXSTRING];
- ssnprintf(server, sizeof(server), "%s:%i",
+ snprintf(server, sizeof(server), "%s:%i",
(smtp_host == NULL) ? DEFAULT_SMTP_HOST : smtp_host, smtp_port);
pthread_mutex_lock(&session_lock);
int buf_len = sizeof(buf);
int i;
- ssnprintf(severity, sizeof(severity), "%s",
+ snprintf(severity, sizeof(severity), "%s",
(n->severity == NOTIF_FAILURE)
? "FAILURE"
: ((n->severity == NOTIF_WARNING)
? "WARNING"
: ((n->severity == NOTIF_OKAY) ? "OKAY" : "UNKNOWN")));
- ssnprintf(subject, sizeof(subject),
+ snprintf(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 */
- ssnprintf(buf, buf_len, "MIME-Version: 1.0\r\n"
+ snprintf(buf, buf_len, "MIME-Version: 1.0\r\n"
"Content-Type: text/plain; charset=\"US-ASCII\"\r\n"
"Content-Transfer-Encoding: 8bit\r\n"
"Subject: %s\r\n"
break;
}
- ssnprintf(buffer, sizeof(buffer),
+ snprintf(buffer, sizeof(buffer),
"[%.0f] PROCESS_SERVICE_CHECK_RESULT;%s;%s;%d;%s\n",
CDTIME_T_TO_DOUBLE(n->time), n->host, &svc_description[1], code,
n->message);
} else if (strcasecmp(key, "Port") == 0) {
int port = (int)(atof(value));
if ((port > 0) && (port <= 65535))
- ssnprintf(ntpd_port, sizeof(ntpd_port), "%i", port);
+ snprintf(ntpd_port, sizeof(ntpd_port), "%i", port);
else
sstrncpy(ntpd_port, value, sizeof(ntpd_port));
} else if (strcasecmp(key, "ReverseLookups") == 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],
+ snprintf(buffer, buffer_size, "%s-%" PRIu32, refclock_names[refclock_id],
unit_id);
else
sstrncpy(buffer, refclock_names[refclock_id], buffer_size);
vl.values_len = 1;
sstrncpy(vl.plugin, "numa", sizeof(vl.plugin));
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "node%i", node);
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "node%i", node);
sstrncpy(vl.type, "vmpage_action", sizeof(vl.type));
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
int status;
int success;
- ssnprintf(path, sizeof(path), NUMA_ROOT_DIR "/node%i/numastat", node);
+ snprintf(path, sizeof(path), NUMA_ROOT_DIR "/node%i/numastat", node);
fh = fopen(path, "r");
if (fh == NULL) {
struct stat statbuf = {0};
int status;
- ssnprintf(path, sizeof(path), NUMA_ROOT_DIR "/node%i", max_node + 1);
+ snprintf(path, sizeof(path), NUMA_ROOT_DIR "/node%i", max_node + 1);
status = stat(path, &statbuf);
if (status == 0) {
if (config_want_links == OLSRD_WANT_DETAIL) {
char type_instance[DATA_MAX_NAME_LEN];
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s-lq", fields[0],
+ snprintf(type_instance, sizeof(type_instance), "%s-%s-lq", fields[0],
fields[1]);
DEBUG("olsrd plugin: links: type_instance = %s; lq = %g;", type_instance,
if (config_want_links == OLSRD_WANT_DETAIL) {
char type_instance[DATA_MAX_NAME_LEN];
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s-rx", fields[0],
+ snprintf(type_instance, sizeof(type_instance), "%s-%s-rx", fields[0],
fields[1]);
DEBUG("olsrd plugin: links: type_instance = %s; nlq = %g;", type_instance,
if (config_want_topology == OLSRD_WANT_DETAIL) {
char type_instance[DATA_MAX_NAME_LEN] = {0};
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s-lq", fields[0],
+ snprintf(type_instance, sizeof(type_instance), "%s-%s-lq", fields[0],
fields[1]);
DEBUG("olsrd plugin: type_instance = %s; lq = %g;", type_instance, lq);
olsrd_submit(/* p.-inst = */ "topology", /* type = */ "signal_quality",
} else {
char type_instance[DATA_MAX_NAME_LEN] = {0};
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s-nlq", fields[0],
+ snprintf(type_instance, sizeof(type_instance), "%s-%s-nlq", fields[0],
fields[1]);
DEBUG("olsrd plugin: type_instance = %s; nlq = %g;", type_instance, nlq);
olsrd_submit(/* p.-inst = */ "topology", /* type = */ "signal_quality",
char subpath[4096];
int status;
- status = ssnprintf(subpath, sizeof(subpath), "%s/main", path);
+ status = snprintf(subpath, sizeof(subpath), "%s/main", path);
if ((status > 0) && (status < (int)sizeof(subpath)))
cow_read_bus(subpath);
- status = ssnprintf(subpath, sizeof(subpath), "%s/aux", path);
+ status = snprintf(subpath, sizeof(subpath), "%s/aux", path);
if ((status > 0) && (status < (int)sizeof(subpath)))
cow_read_bus(subpath);
dummy = NULL;
if (strcmp("/", path) == 0)
- status = ssnprintf(subpath, sizeof(subpath), "/%s", buffer_ptr);
+ status = snprintf(subpath, sizeof(subpath), "/%s", buffer_ptr);
else
- status = ssnprintf(subpath, sizeof(subpath), "%s/%s", path, buffer_ptr);
+ status = snprintf(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];
- ssnprintf(typeinst, sizeof(typeinst), "bdbentrycache-%s",
+ snprintf(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];
- ssnprintf(typeinst, sizeof(typeinst), "bdbdncache-%s",
+ snprintf(typeinst, sizeof(typeinst), "bdbdncache-%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, "olmBDBIDLCache")) !=
NULL) {
olmbdb_data = *olmbdb_list[0];
- ssnprintf(typeinst, sizeof(typeinst), "bdbidlcache-%s",
+ snprintf(typeinst, sizeof(typeinst), "bdbidlcache-%s",
nc_data.bv_val);
cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
st);
databases[databases_num] = st;
databases_num++;
- ssnprintf(callback_name, sizeof(callback_name), "openldap/%s/%s",
+ snprintf(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];
- ssnprintf(errfunc, sizeof(errfunc), "OCILogon(\"%s\")", db->connect_id);
+ snprintf(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 = ssnprintf(opt_buff + buff_off, buff_size - buff_off, option_fmt,
+ int ret = snprintf(opt_buff + buff_off, buff_size - buff_off, option_fmt,
iface->name);
if (ret < 0) {
sfree(opt_buff);
}
/* create OVS DB select params */
- if (ssnprintf(params_buff, params_size, params_fmt, opt_buff) < 0)
+ if (snprintf(params_buff, params_size, params_fmt, opt_buff) < 0)
sfree(params_buff);
sfree(opt_buff);
}
/* fill the notification data */
- ssnprintf(n.message, sizeof(n.message),
+ snprintf(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));
static char *get_module_name(char *buf, size_t buf_len, const char *module) {
int status = 0;
if (base_name[0] == '\0')
- status = ssnprintf(buf, buf_len, "%s", module);
+ status = snprintf(buf, buf_len, "%s", module);
else
- status = ssnprintf(buf, buf_len, "%s::%s", base_name, module);
+ status = snprintf(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 = ssnprintf(buf, buf_len, " %s = '%s'", parameter, value); \
+ int s = snprintf(buf, buf_len, " %s = '%s'", parameter, value); \
if (0 < s) { \
buf += s; \
buf_len -= s; \
if ((!db) || (!db->database))
return -1;
- status = ssnprintf(buf, buf_len, "dbname = '%s'", db->database);
+ status = snprintf(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:
- ssnprintf(interval, sizeof(interval), "%.3f",
+ snprintf(interval, sizeof(interval), "%.3f",
(db->interval > 0) ? CDTIME_T_TO_DOUBLE(db->interval)
: plugin_get_interval());
params[i] = interval;
str_len = string_len;
for (size_t i = 0; i < ds->ds_num; ++i) {
- int status = ssnprintf(str_ptr, str_len, ",'%s'", ds->ds[i].name);
+ int status = snprintf(str_ptr, str_len, ",'%s'", ds->ds[i].name);
if (status < 1)
return NULL;
int status;
if (store_rates)
- status = ssnprintf(str_ptr, str_len, ",'gauge'");
+ status = snprintf(str_ptr, str_len, ",'gauge'");
else
- status = ssnprintf(str_ptr, str_len, ",'%s'",
+ status = snprintf(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 =
- ssnprintf(str_ptr, str_len, "," GAUGE_FORMAT, vl->values[i].gauge);
+ snprintf(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 = ssnprintf(str_ptr, str_len, ",%lf", rates[i]);
+ status = snprintf(str_ptr, str_len, ",%lf", rates[i]);
} else if (ds->ds[i].type == DS_TYPE_COUNTER)
- status = ssnprintf(str_ptr, str_len, ",%llu", vl->values[i].counter);
+ status = snprintf(str_ptr, str_len, ",%llu", vl->values[i].counter);
else if (ds->ds[i].type == DS_TYPE_DERIVE)
- status = ssnprintf(str_ptr, str_len, ",%" PRIi64, vl->values[i].derive);
+ status = snprintf(str_ptr, str_len, ",%" PRIi64, vl->values[i].derive);
else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
- status = ssnprintf(str_ptr, str_len, ",%" PRIu64, vl->values[i].absolute);
+ status = snprintf(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];
- ssnprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->database);
+ snprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->database);
if (!had_flush) {
plugin_unregister_flush("postgresql");
}
}
- ssnprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->instance);
+ snprintf(cb_name, sizeof(cb_name), "postgresql-%s", db->instance);
user_data_t ud = {.data = db, .free_func = c_psql_database_delete};
char *fields[8];
int numfields;
- ssnprintf(dirname, sizeof(dirname), "/proc/%li/task", ps->id);
+ snprintf(dirname, sizeof(dirname), "/proc/%li/task", ps->id);
if ((dh = opendir(dirname)) == NULL) {
DEBUG("Failed to open directory `%s'", dirname);
tpid = ent->d_name;
- ssnprintf(filename, sizeof(filename), "/proc/%li/task/%s/status", ps->id,
+ snprintf(filename, sizeof(filename), "/proc/%li/task/%s/status", ps->id,
tpid);
if ((fh = fopen(filename, "r")) == NULL) {
DEBUG("Failed to open file `%s'", filename);
char *fields[8];
int numfields;
- ssnprintf(filename, sizeof(filename), "/proc/%li/status", pid);
+ snprintf(filename, sizeof(filename), "/proc/%li/status", pid);
if ((fh = fopen(filename, "r")) == NULL)
return -1;
char *fields[8];
int numfields;
- ssnprintf(filename, sizeof(filename), "/proc/%li/io", ps->id);
+ snprintf(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;
struct dirent *ent;
int count = 0;
- ssnprintf(dirname, sizeof(dirname), "/proc/%i/fd", pid);
+ snprintf(dirname, sizeof(dirname), "/proc/%i/fd", pid);
if ((dh = opendir(dirname)) == NULL) {
DEBUG("Failed to open directory `%s'", dirname);
ssize_t status;
- ssnprintf(filename, sizeof(filename), "/proc/%li/stat", pid);
+ snprintf(filename, sizeof(filename), "/proc/%li/stat", pid);
status = read_file_contents(filename, buffer, sizeof(buffer) - 1);
if (status <= 0)
if ((pid < 1) || (NULL == buf) || (buf_len < 2))
return NULL;
- ssnprintf(file, sizeof(file), "/proc/%li/cmdline", pid);
+ snprintf(file, sizeof(file), "/proc/%li/cmdline", pid);
errno = 0;
fd = open(file, O_RDONLY);
if (NULL == name)
return NULL;
- ssnprintf(buf, buf_len, "[%s]", name);
+ snprintf(buf, buf_len, "[%s]", name);
return buf;
}
if (values_list != NULL) {
char match_name[2 * DATA_MAX_NAME_LEN];
- ssnprintf(match_name, sizeof(match_name), "%s:%s", key_buffer,
+ snprintf(match_name, sizeof(match_name), "%s:%s", key_buffer,
key_fields[i]);
if (ignorelist_match(values_list, match_name))
char *str;
int i;
- ssnprintf(field_name, sizeof(field_name), "db%d:keys=", db);
+ snprintf(field_name, sizeof(field_name), "db%d:keys=", db);
str = strstr(info_line, field_name);
if (!str)
return -1;
}
- ssnprintf(db_id, sizeof(db_id), "%d", db);
+ snprintf(db_id, sizeof(db_id), "%d", db);
redis_submit(node, "records", db_id, val);
}
return 0;
return;
/*** RX ***/
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s-rx", r->interface,
+ snprintf(type_instance, sizeof(type_instance), "%s-%s-rx", r->interface,
r->radio_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 ***/
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s-tx", r->interface,
+ snprintf(type_instance, sizeof(type_instance), "%s-%s-tx", r->interface,
r->radio_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 ***/
- ssnprintf(type_instance, sizeof(type_instance), "%s-%s", r->interface,
+ snprintf(type_instance, sizeof(type_instance), "%s-%s", r->interface,
r->radio_name);
cr_submit_io(rd, "if_octets", type_instance, (derive_t)r->rx_bytes,
(derive_t)r->tx_bytes);
}
}
- ssnprintf(read_name, sizeof(read_name), "routeros/%s", router_data->node);
+ snprintf(read_name, sizeof(read_name), "routeros/%s", router_data->node);
if (status == 0)
status = plugin_register_complex_read(
/* group = */ NULL, read_name, cr_read, /* interval = */ 0,
memset(buffer, '\0', buffer_len);
t = CDTIME_T_TO_TIME_T(vl->time);
- status = ssnprintf(buffer, buffer_len, "%lu", (unsigned long)t);
+ status = snprintf(buffer, buffer_len, "%lu", (unsigned long)t);
if ((status < 1) || (status >= buffer_len))
return -1;
offset = status;
return -1;
if (ds->ds[i].type == DS_TYPE_COUNTER) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ":%llu",
+ status = snprintf(buffer + offset, buffer_len - offset, ":%llu",
vl->values[i].counter);
} else if (ds->ds[i].type == DS_TYPE_GAUGE) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ":%f",
+ status = snprintf(buffer + offset, buffer_len - offset, ":%f",
vl->values[i].gauge);
} else if (ds->ds[i].type == DS_TYPE_DERIVE) {
- status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
+ status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
vl->values[i].derive);
} else /* if (ds->ds[i].type == DS_TYPE_ABSOLUTE) */ {
- status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
+ status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
vl->values[i].absolute);
}
return EINVAL;
if (datadir != NULL)
- ssnprintf(filename, sizeof(filename), "%s/%s.rrd", datadir, identifier);
+ snprintf(filename, sizeof(filename), "%s/%s.rrd", datadir, identifier);
else
- ssnprintf(filename, sizeof(filename), "%s.rrd", identifier);
+ snprintf(filename, sizeof(filename), "%s.rrd", identifier);
rrd_clear_error();
status = rrdc_connect(daemon_address);
memset(buffer, '\0', buffer_len);
tt = CDTIME_T_TO_TIME_T(vl->time);
- status = ssnprintf(buffer, buffer_len, "%u", (unsigned int)tt);
+ status = snprintf(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 = ssnprintf(buffer + offset, buffer_len - offset, ":%llu",
+ status = snprintf(buffer + offset, buffer_len - offset, ":%llu",
vl->values[i].counter);
else if (ds->ds[i].type == DS_TYPE_GAUGE)
- status = ssnprintf(buffer + offset, buffer_len - offset, ":" GAUGE_FORMAT,
+ status = snprintf(buffer + offset, buffer_len - offset, ":" GAUGE_FORMAT,
vl->values[i].gauge);
else if (ds->ds[i].type == DS_TYPE_DERIVE)
- status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
+ status = snprintf(buffer + offset, buffer_len - offset, ":%" PRIi64,
vl->values[i].derive);
else /*if (ds->ds[i].type == DS_TYPE_ABSOLUTE) */
- status = ssnprintf(buffer + offset, buffer_len - offset, ":%" PRIu64,
+ status = snprintf(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 = ssnprintf(buffer, buffer_len, "%u:%" PRIi64, (unsigned)tt,
+ status = snprintf(buffer, buffer_len, "%u:%" PRIi64, (unsigned)tt,
vl->values[0].derive);
break;
case DS_TYPE_GAUGE:
- status = ssnprintf(buffer, buffer_len, "%u:" GAUGE_FORMAT, (unsigned)tt,
+ status = snprintf(buffer, buffer_len, "%u:" GAUGE_FORMAT, (unsigned)tt,
vl->values[0].gauge);
break;
case DS_TYPE_COUNTER:
- status = ssnprintf(buffer, buffer_len, "%u:%llu", (unsigned)tt,
+ status = snprintf(buffer, buffer_len, "%u:%llu", (unsigned)tt,
vl->values[0].counter);
break;
case DS_TYPE_ABSOLUTE:
- status = ssnprintf(buffer, buffer_len, "%u:%" PRIu64, (unsigned)tt,
+ status = snprintf(buffer, buffer_len, "%u:%" PRIu64, (unsigned)tt,
vl->values[0].absolute);
break;
default:
int status = -1;
if (chip->bus == SENSORS_CHIP_NAME_BUS_ISA) {
- status = ssnprintf(buf, buf_size, "%s-isa-%04x", chip->prefix, chip->addr);
+ status = snprintf(buf, buf_size, "%s-isa-%04x", chip->prefix, chip->addr);
} else if (chip->bus == SENSORS_CHIP_NAME_BUS_DUMMY) {
status = snprintf(buf, buf_size, "%s-%s-%04x", chip->prefix, chip->busname,
chip->addr);
value_list_t vl = VALUE_LIST_INIT;
- status = ssnprintf(match_key, sizeof(match_key), "%s/%s-%s", plugin_instance,
+ status = snprintf(match_key, sizeof(match_key), "%s/%s-%s", plugin_instance,
type, type_instance);
if (status < 1)
return;
}
cfdev->sdi = devlist->data;
g_slist_free(devlist);
- ssnprintf(hwident, sizeof(hwident), "%s %s %s",
+ snprintf(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));
- ssnprintf(notif.message, sizeof(notif.message),
+ snprintf(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++) {
- ssnprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
+ snprintf(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);
- ssnprintf(cb_name, sizeof(cb_name), "snmp-%s", hd->name);
+ snprintf(cb_name, sizeof(cb_name), "snmp-%s", hd->name);
status = plugin_register_complex_read(
/* group = */ NULL, cb_name, csnmp_read_host, hd->interval,
else if (vb->type == ASN_BIT_STR)
src = (char *)vb->val.bitstring;
else if (vb->type == ASN_IPADDRESS) {
- return ssnprintf(dst, dst_size,
+ return snprintf(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);
- ssnprintf(il->instance, sizeof(il->instance), "%llu", val.counter);
+ snprintf(il->instance, sizeof(il->instance), "%llu", val.counter);
}
/* TODO: Debugging output */
if (data->instance_prefix == NULL)
sstrncpy(vl.type_instance, temp, sizeof(vl.type_instance));
else
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s%s",
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s%s",
data->instance_prefix, temp);
}
char *oid_str_ptr[MAX_OID_LEN];
for (size_t i = 0; i < o->oid_len; i++) {
- ssnprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
+ snprintf(oid_str[i], sizeof(oid_str[i]), "%lu", (unsigned long)o->oid[i]);
oid_str_ptr[i] = oid_str[i];
}
.severity = NOTIF_WARNING, .time = cdtime(), .plugin = PLUGIN_NAME};
sstrncpy(n.host, hostname_g, sizeof(n.host));
sstrncpy(n.plugin_instance, ins, sizeof(n.plugin_instance));
- ssnprintf(n.message, sizeof(n.message),
+ snprintf(n.message, sizeof(n.message),
"Removed data row from table %s instance %s index %d", td->name,
ins, (index != NULL) ? *index : -1);
plugin_dispatch_notification(&n);
.severity = NOTIF_OKAY, .time = cdtime(), .plugin = PLUGIN_NAME};
sstrncpy(n.host, hostname_g, sizeof(n.host));
sstrncpy(n.plugin_instance, ins, sizeof(n.plugin_instance));
- ssnprintf(n.message, sizeof(n.message),
+ snprintf(n.message, sizeof(n.message),
"Data row added to table %s instance %s index %d", td->name, ins,
(index != NULL) ? *index : -1);
plugin_dispatch_notification(&n);
/* Make sure all timer metrics share the *same* timestamp. */
vl.time = cdtime();
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-average", name);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-average", name);
vl.values[0].gauge =
have_events
? CDTIME_T_TO_DOUBLE(latency_counter_get_average(metric->latency))
plugin_dispatch_values(&vl);
if (conf_timer_lower) {
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-lower", name);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-lower", name);
vl.values[0].gauge =
have_events
? CDTIME_T_TO_DOUBLE(latency_counter_get_min(metric->latency))
}
if (conf_timer_upper) {
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-upper", name);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-upper", name);
vl.values[0].gauge =
have_events
? CDTIME_T_TO_DOUBLE(latency_counter_get_max(metric->latency))
}
if (conf_timer_sum) {
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-sum", name);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-sum", name);
vl.values[0].gauge =
have_events
? CDTIME_T_TO_DOUBLE(latency_counter_get_sum(metric->latency))
}
for (size_t i = 0; i < conf_timer_percentile_num; i++) {
- ssnprintf(vl.type_instance, sizeof(vl.type_instance),
+ snprintf(vl.type_instance, sizeof(vl.type_instance),
"%s-percentile-%.0f", name, conf_timer_percentile[i]);
vl.values[0].gauge =
have_events ? CDTIME_T_TO_DOUBLE(latency_counter_get_percentile(
* vl.type's above are implicitly set to "latency". */
if (conf_timer_count) {
sstrncpy(vl.type, "gauge", sizeof(vl.type));
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-count", name);
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-count", name);
vl.values[0].gauge = latency_counter_get_num(metric->latency);
plugin_dispatch_values(&vl);
}
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(&buf[offset], sizeof(buf) - offset, __VA_ARGS__); \
+ status = snprintf(&buf[offset], sizeof(buf) - offset, __VA_ARGS__); \
if (status < 1) \
return -1; \
else if (((size_t)status) >= (sizeof(buf) - offset)) \
}
for (size_t i = 0; i < tail_match_list_num; i++) {
- ssnprintf(str, sizeof(str), "tail-%zu", i);
+ snprintf(str, sizeof(str), "tail-%zu", i);
plugin_register_complex_read(NULL, str, ctail_read,
tail_match_list_intervals[i],
return -1;
}
- ssnprintf(cb_name, sizeof(cb_name), "tail_csv/%s", id->path);
+ snprintf(cb_name, sizeof(cb_name), "tail_csv/%s", id->path);
status = plugin_register_complex_read(
NULL, cb_name, tcsv_read, id->interval,
char template[DATA_MAX_NAME_LEN];
char value_str[DATA_MAX_NAME_LEN];
- ssnprintf(template, sizeof(template), "%%{ds:%s}", ds->ds[i].name);
+ snprintf(template, sizeof(template), "%%{ds:%s}", ds->ds[i].name);
if (ds->ds[i].type != DS_TYPE_GAUGE) {
if ((rates == NULL) && (rates_failed == 0)) {
/* If this is a gauge value, use the current value. */
if (ds->ds[i].type == DS_TYPE_GAUGE)
- ssnprintf(value_str, sizeof(value_str), GAUGE_FORMAT,
+ snprintf(value_str, sizeof(value_str), GAUGE_FORMAT,
(double)vl->values[i].gauge);
/* If it's a counter, try to use the current rate. This may fail, if the
* value has been renamed. */
else if (rates != NULL)
- ssnprintf(value_str, sizeof(value_str), GAUGE_FORMAT, (double)rates[i]);
+ snprintf(value_str, sizeof(value_str), GAUGE_FORMAT, (double)rates[i]);
/* Since we don't know any better, use the string `unknown'. */
else
sstrncpy(value_str, "unknown", sizeof(value_str));
curr_counter = (uint64_t)vl->values[dsrc_index].counter;
- ssnprintf(key_prev_counter, sizeof(key_prev_counter),
+ snprintf(key_prev_counter, sizeof(key_prev_counter),
"target_scale[%p,%i]:prev_counter", (void *)data, dsrc_index);
- ssnprintf(key_int_counter, sizeof(key_int_counter),
+ snprintf(key_int_counter, sizeof(key_int_counter),
"target_scale[%p,%i]:int_counter", (void *)data, dsrc_index);
- ssnprintf(key_int_fraction, sizeof(key_int_fraction),
+ snprintf(key_int_fraction, sizeof(key_int_fraction),
"target_scale[%p,%i]:int_fraction", (void *)data, dsrc_index);
prev_counter = curr_counter;
curr_derive = (int64_t)vl->values[dsrc_index].derive;
- ssnprintf(key_prev_derive, sizeof(key_prev_derive),
+ snprintf(key_prev_derive, sizeof(key_prev_derive),
"target_scale[%p,%i]:prev_derive", (void *)data, dsrc_index);
- ssnprintf(key_int_derive, sizeof(key_int_derive),
+ snprintf(key_int_derive, sizeof(key_int_derive),
"target_scale[%p,%i]:int_derive", (void *)data, dsrc_index);
- ssnprintf(key_int_fraction, sizeof(key_int_fraction),
+ snprintf(key_int_fraction, sizeof(key_int_fraction),
"target_scale[%p,%i]:int_fraction", (void *)data, dsrc_index);
prev_derive = curr_derive;
curr_absolute = (uint64_t)vl->values[dsrc_index].absolute;
- ssnprintf(key_int_fraction, sizeof(key_int_fraction),
+ snprintf(key_int_fraction, sizeof(key_int_fraction),
"target_scale[%p,%i]:int_fraction", (void *)data, dsrc_index);
int_fraction = 0.0;
char *value_str;
const char *key = meta_toc[i];
- ssnprintf(meta_name, sizeof(meta_name), "%%{meta:%s}", key);
+ snprintf(meta_name, sizeof(meta_name), "%%{meta:%s}", key);
if (meta_data_as_string(vl->meta, key, &value_str) != 0)
continue;
/* Dispatch new value lists instead of this one */
new_vl.values[0].derive = (derive_t)vl->values[0].counter;
- ssnprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
+ snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
"demand_data-%s", is_hits ? "hit" : "miss");
plugin_dispatch_values(&new_vl);
new_vl.values[0].derive = (derive_t)vl->values[1].counter;
- ssnprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
+ snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
"demand_metadata-%s", is_hits ? "hit" : "miss");
plugin_dispatch_values(&new_vl);
new_vl.values[0].derive = (derive_t)vl->values[2].counter;
- ssnprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
+ snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
"prefetch_data-%s", is_hits ? "hit" : "miss");
plugin_dispatch_values(&new_vl);
new_vl.values[0].derive = (derive_t)vl->values[3].counter;
- ssnprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
+ snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
"prefetch_metadata-%s", is_hits ? "hit" : "miss");
plugin_dispatch_values(&new_vl);
if (((port_collect_listening != 0) && (pe->flags & PORT_IS_LISTENING)) ||
(pe->flags & PORT_COLLECT_LOCAL)) {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance),
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance),
"%" PRIu16 "-local", pe->port);
for (int i = 1; i <= TCP_STATE_MAX; i++) {
}
if (pe->flags & PORT_COLLECT_REMOTE) {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance),
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance),
"%" PRIu16 "-remote", pe->port);
for (int i = 1; i <= TCP_STATE_MAX; i++) {
int status;
/* Send request */
- ssnprintf(command, sizeof(command), "sel %i\r\n", vserver->port);
+ snprintf(command, sizeof(command), "sel %i\r\n", vserver->port);
status = tss2_send_request(write_fh, command);
if (status != 0) {
status = tss2_send_request(write_fh, "gi\r\n");
} else {
/* Request server information */
- ssnprintf(plugin_instance, sizeof(plugin_instance), "vserver%i",
+ snprintf(plugin_instance, sizeof(plugin_instance), "vserver%i",
vserver->port);
/* Select the server */
if (device_list && ignorelist_match(device_list, name))
return -1;
- ssnprintf(filename, sizeof(filename), "%s/%s/temp", dirname_sysfs, name);
+ snprintf(filename, sizeof(filename), "%s/%s/temp", dirname_sysfs, name);
if (parse_value_file(filename, &value, DS_TYPE_GAUGE) == 0) {
value.gauge /= 1000.0;
thermal_submit(name, TEMP, value);
success = 1;
}
- ssnprintf(filename, sizeof(filename), "%s/%s/cur_state", dirname_sysfs, name);
+ snprintf(filename, sizeof(filename), "%s/%s/cur_state", dirname_sysfs, name);
if (parse_value_file(filename, &value, DS_TYPE_GAUGE) == 0) {
thermal_submit(name, COOLING_DEV, value);
success = 1;
* temperature: 55 C
*/
- len = ssnprintf(filename, sizeof(filename), "%s/%s/temperature",
+ len = snprintf(filename, sizeof(filename), "%s/%s/temperature",
dirname_procfs, name);
if ((len < 0) || ((size_t)len >= sizeof(filename)))
return -1;
n.time = vl->time;
- status = ssnprintf(buf, bufsize, "Host %s, plugin %s", vl->host, vl->plugin);
+ status = snprintf(buf, bufsize, "Host %s, plugin %s", vl->host, vl->plugin);
buf += status;
bufsize -= status;
if (vl->plugin_instance[0] != '\0') {
- status = ssnprintf(buf, bufsize, " (instance %s)", vl->plugin_instance);
+ status = snprintf(buf, bufsize, " (instance %s)", vl->plugin_instance);
buf += status;
bufsize -= status;
}
- status = ssnprintf(buf, bufsize, " type %s", vl->type);
+ status = snprintf(buf, bufsize, " type %s", vl->type);
buf += status;
bufsize -= status;
if (vl->type_instance[0] != '\0') {
- status = ssnprintf(buf, bufsize, " (instance %s)", vl->type_instance);
+ status = snprintf(buf, bufsize, " (instance %s)", vl->type_instance);
buf += status;
bufsize -= status;
}
/* Send an okay notification */
if (state == STATE_OKAY) {
if (state_old == STATE_MISSING)
- ssnprintf(buf, bufsize, ": Value is no longer missing.");
+ snprintf(buf, bufsize, ": Value is no longer missing.");
else
- ssnprintf(buf, bufsize, ": All data sources are within range again. "
+ snprintf(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 (th->flags & UT_FLAG_INVERT) {
if (!isnan(min) && !isnan(max)) {
- ssnprintf(buf, bufsize,
+ snprintf(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 {
- ssnprintf(buf, bufsize, ": Data source \"%s\" is currently "
+ snprintf(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;
- ssnprintf(buf, bufsize,
+ snprintf(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 */
{
- ssnprintf(buf, bufsize, ": Data source \"%s\" is currently "
+ snprintf(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);
- ssnprintf(n.message, sizeof(n.message),
+ snprintf(n.message, sizeof(n.message),
"%s has not been updated for %.3f seconds.", identifier,
CDTIME_T_TO_DOUBLE(missing_time));
n.time = now;
}
}
- ssnprintf(pathname, sizeof(pathname), "/dev/cpu/%d/msr", cpu);
+ snprintf(pathname, sizeof(pathname), "/dev/cpu/%d/msr", cpu);
fd = open(pathname, O_RDONLY);
if (fd < 0) {
ERROR("turbostat plugin: failed to open %s", pathname);
DEBUG("turbostat plugin: submit stats for cpu: %d, core: %d, pkg: %d",
t->cpu_id, c->core_id, p->package_id);
- ssnprintf(name, sizeof(name), "cpu%02d", t->cpu_id);
+ snprintf(name, sizeof(name), "cpu%02d", t->cpu_id);
if (!aperf_mperf_unstable)
turbostat_submit(name, "percent", "c0", 100.0 * t->mperf / t->tsc);
/* If not using logical core numbering, set core id */
if (!config_lcn) {
- ssnprintf(name, sizeof(name), "core%02d", c->core_id);
+ snprintf(name, sizeof(name), "core%02d", c->core_id);
}
if (do_core_cstate & (1 << 3))
if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
goto done;
- ssnprintf(name, sizeof(name), "pkg%02d", p->package_id);
+ snprintf(name, sizeof(name), "pkg%02d", p->package_id);
if (do_ptm)
turbostat_submit(name, "temperature", NULL, p->pkg_temp_c);
int matches;
char character;
- ssnprintf(path, sizeof(path),
+ snprintf(path, sizeof(path),
"/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
filep = fopen(path, "r");
if (!filep) {
return status;
escape_string(buffer_values, sizeof(buffer_values));
- ssnprintf(ret, ret_len, "PUTVAL %s interval=%.3f %s", buffer_ident,
+ snprintf(ret, ret_len, "PUTVAL %s interval=%.3f %s", buffer_ident,
(vl->interval > 0) ? CDTIME_T_TO_DOUBLE(vl->interval)
: CDTIME_T_TO_DOUBLE(plugin_get_interval()),
buffer_values);
return "ANY"; /* ... 255 */
#endif /* __BIND >= 19950621 */
default:
- ssnprintf(buf, sizeof(buf), "#%i", t);
+ snprintf(buf, sizeof(buf), "#%i", t);
return buf;
} /* switch (t) */
}
case 5:
return "Update";
default:
- ssnprintf(buf, sizeof(buf), "Opcode%d", o);
+ snprintf(buf, sizeof(buf), "Opcode%d", o);
return buf;
}
}
#endif /* RFC2136 rcodes */
#endif /* __BIND >= 19950621 */
default:
- ssnprintf(buf, sizeof(buf), "RCode%i", rcode);
+ snprintf(buf, sizeof(buf), "RCode%i", rcode);
return buf;
}
} /* const char *rcode_str (int rcode) */
DPDK_HELPER_TRACE(phc->shm_name);
- 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.process_type, DATA_MAX_NAME_LEN, "%s", "secondary");
- ssnprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN, "%s",
+ 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.process_type, DATA_MAX_NAME_LEN, "%s", "secondary");
+ snprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN, "%s",
DPDK_DEFAULT_RTE_CONFIG);
}
DEBUG("dpdk_common: EAL:Process type %s", phc->eal_config.process_type);
} else if ((strcasecmp("FilePrefix", child->key) == 0) &&
(child->values[0].type == OCONFIG_TYPE_STRING)) {
- ssnprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN,
+ snprintf(phc->eal_config.file_prefix, DATA_MAX_NAME_LEN,
"/var/run/.%s_config", child->values[0].value.string);
DEBUG("dpdk_common: EAL:File prefix %s", phc->eal_config.file_prefix);
} else {
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
+ status = snprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
if (status < 1) { \
return -1; \
} else if (((size_t)status) >= (ret_len - offset)) { \
sizeof(n_type_instance), escape_char, preserve_separator);
if (n_plugin_instance[0] != '\0')
- ssnprintf(tmp_plugin, sizeof(tmp_plugin), "%s%c%s", n_plugin,
+ snprintf(tmp_plugin, sizeof(tmp_plugin), "%s%c%s", n_plugin,
(flags & GRAPHITE_SEPARATE_INSTANCES) ? '.' : '-',
n_plugin_instance);
else
if ((flags & GRAPHITE_DROP_DUPE_FIELDS) && strcmp(n_plugin, n_type) == 0)
sstrncpy(tmp_type, n_type_instance, sizeof(tmp_type));
else
- ssnprintf(tmp_type, sizeof(tmp_type), "%s%c%s", n_type,
+ snprintf(tmp_type, sizeof(tmp_type), "%s%c%s", n_type,
(flags & GRAPHITE_SEPARATE_INSTANCES) ? '.' : '-',
n_type_instance);
} else
if (ds_name != NULL) {
if ((flags & GRAPHITE_DROP_DUPE_FIELDS) &&
strcmp(tmp_plugin, tmp_type) == 0)
- ssnprintf(ret, ret_len, "%s%s%s.%s.%s", prefix, n_host, postfix,
+ snprintf(ret, ret_len, "%s%s%s.%s.%s", prefix, n_host, postfix,
tmp_plugin, ds_name);
else
- ssnprintf(ret, ret_len, "%s%s%s.%s.%s.%s", prefix, n_host, postfix,
+ snprintf(ret, ret_len, "%s%s%s.%s.%s.%s", prefix, n_host, postfix,
tmp_plugin, tmp_type, ds_name);
} else
- ssnprintf(ret, ret_len, "%s%s%s.%s.%s", prefix, n_host, postfix, tmp_plugin,
+ snprintf(ret, ret_len, "%s%s%s.%s.%s", prefix, n_host, postfix, tmp_plugin,
tmp_type);
return 0;
/* Compute the graphite command */
message_len =
- (size_t)ssnprintf(message, sizeof(message), "%s %s %u\r\n", key, values,
+ (size_t)snprintf(message, sizeof(message), "%s %s %u\r\n", key, values,
(unsigned int)CDTIME_T_TO_TIME_T(vl->time));
if (message_len >= sizeof(message)) {
ERROR("format_graphite: message buffer too small: "
#define BUFFER_ADD(...) \
do { \
int status; \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
return -1; \
#define BUFFER_ADD(...) \
do { \
int status; \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
#define BUFFER_ADD(...) \
do { \
int status; \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
#define BUFFER_ADD(...) \
do { \
int status; \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
return -1; \
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
+ status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
return -1; \
else if (((size_t)status) >= (buffer_size - offset)) \
* (This is useful, if the cdrom on /dev/hdc must not
* be accessed.)
*/
- ssnprintf(device, sizeof(device), "%s/%s", DEVLABELDIR, ptname);
+ snprintf(device, sizeof(device), "%s/%s", DEVLABELDIR, ptname);
if (!get_label_uuid(device, &label, uuid)) {
uuidcache_addentry(sstrdup(device), label, uuid);
}
/* generate id field */
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "id");
uid = ovs_uid_generate();
- ssnprintf(uid_buff, sizeof(uid_buff), "%" PRIX64, uid);
+ snprintf(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> */
- ssnprintf(uid_str, sizeof(uid_str), "%" PRIX64, new_cb->uid);
+ snprintf(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 = ssnprintf(buffer, sizeof(buffer), "RRA:%s:%.10f:%u:%u",
+ status = snprintf(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
- ssnprintf(min, sizeof(min), "%f", d->min);
+ snprintf(min, sizeof(min), "%f", d->min);
if (isnan(d->max)) {
sstrncpy(max, "U", sizeof(max));
} else
- ssnprintf(max, sizeof(max), "%f", d->max);
+ snprintf(max, sizeof(max), "%f", d->max);
- status = ssnprintf(buffer, sizeof(buffer), "DS:%s:%s:%i:%s:%s", d->name,
+ status = snprintf(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;
- ssnprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
- ssnprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
+ snprintf(pdp_step_str, sizeof(pdp_step_str), "%lu", pdp_step);
+ snprintf(last_up_str, sizeof(last_up_str), "%lu", (unsigned long)last_up);
new_argv[0] = "create";
new_argv[1] = (void *)filename;
return 0;
}
- ssnprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
+ snprintf(tmpfile, sizeof(tmpfile), "%s.async", args->filename);
status = srrd_create(tmpfile, args->pdp_step, args->last_up, args->argc,
(void *)args->argv);
sstrncpy(vl.type, data->type, sizeof(vl.type));
for (size_t i = 0; i < data->latency_config.percentile_num; i++) {
if (strlen(data->type_instance) != 0)
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%.0f",
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%.0f",
data->type_instance, data->latency_config.percentile[i]);
else
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%.0f",
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%.0f",
data->latency_config.percentile[i]);
vl.values = &(value_t){
bucket.upper_bound ? CDTIME_T_TO_DOUBLE(bucket.upper_bound) : INFINITY;
if (strlen(data->type_instance) != 0)
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s-%g_%g",
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s-%g_%g",
data->type, data->type_instance, lower_bound, upper_bound);
else
- ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%g_%g",
+ snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%g_%g",
data->type, lower_bound, upper_bound);
vl.values = &(value_t){
if (plugin_instance == NULL)
plugin_instance = "default";
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
plugin_instance, category);
sstrncpy(vl.type, type, sizeof(vl.type));
return EINVAL;
}
- ssnprintf(callback_name, sizeof(callback_name), "varnish/%s",
+ snprintf(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];
- ssnprintf(type_instance, sizeof(type_instance), "%d", vcpu_nr);
+ snprintf(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];
- ssnprintf(flush_type_instance, sizeof(flush_type_instance), "flush-%s",
+ snprintf(flush_type_instance, sizeof(flush_type_instance), "flush-%s",
type_instance);
if ((binfo->bi.rd_req != -1) && (binfo->bi.wr_req != -1))
const char *reason_str = "N/A";
#endif
- ssnprintf(msg, sizeof(msg), "Domain state: %s. Reason: %s", state_str,
+ snprintf(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) ? 1 : 0;
- ssnprintf(type_instance, sizeof(type_instance), "vcpu_%d-cpu_%d", vcpu,
+ snprintf(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));
- ssnprintf(inst->tag, sizeof(inst->tag), "%s-%zu", PLUGIN_NAME, i);
+ snprintf(inst->tag, sizeof(inst->tag), "%s-%zu", PLUGIN_NAME, i);
inst->id = i;
user_data_t *ud = &(lv_ud->ud);
goto done;
}
- ssnprintf(xpath_str, sizeof(xpath_str), "/domain/metadata/%s:%s/text()",
+ snprintf(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) {
ERROR(PLUGIN_NAME " plugin: malloc failed.");
return 0;
}
- ssnprintf(name, n, "%s:%s", domname, devpath);
+ snprintf(name, n, "%s:%s", domname, devpath);
r = ignorelist_match(il, name);
sfree(name);
return r;
if (dent->d_name[0] == '.')
continue;
- len = ssnprintf(file, sizeof(file), PROCDIR "/%s", dent->d_name);
+ len = snprintf(file, sizeof(file), PROCDIR "/%s", dent->d_name);
if ((len < 0) || (len >= BUFSIZE))
continue;
continue;
/* socket message accounting */
- len = ssnprintf(file, sizeof(file), PROCDIR "/%s/cacct", dent->d_name);
+ len = snprintf(file, sizeof(file), PROCDIR "/%s/cacct", dent->d_name);
if ((len < 0) || ((size_t)len >= sizeof(file)))
continue;
}
/* thread information and load */
- len = ssnprintf(file, sizeof(file), PROCDIR "/%s/cvirt", dent->d_name);
+ len = snprintf(file, sizeof(file), PROCDIR "/%s/cvirt", dent->d_name);
if ((len < 0) || ((size_t)len >= sizeof(file)))
continue;
}
/* processes and memory usage */
- len = ssnprintf(file, sizeof(file), PROCDIR "/%s/limit", dent->d_name);
+ len = snprintf(file, sizeof(file), PROCDIR "/%s/limit", dent->d_name);
if ((len < 0) || ((size_t)len >= sizeof(file)))
continue;
/* FIXME: Legacy configuration syntax. */
if (cb->name == NULL)
- ssnprintf(callback_name, sizeof(callback_name), "write_graphite/%s/%s/%s",
+ snprintf(callback_name, sizeof(callback_name), "write_graphite/%s/%s/%s",
cb->node, cb->service, cb->protocol);
else
- ssnprintf(callback_name, sizeof(callback_name), "write_graphite/%s",
+ snprintf(callback_name, sizeof(callback_name), "write_graphite/%s",
cb->name);
plugin_register_write(callback_name, wg_write,
return -1;
}
- ssnprintf(cb->credentials, credentials_size, "%s:%s", cb->user,
+ snprintf(cb->credentials, credentials_size, "%s:%s", cb->user,
(cb->pass == NULL) ? "" : cb->pass);
curl_easy_setopt(cb->curl, CURLOPT_USERPWD, cb->credentials);
#endif
return status;
}
- command_len = (size_t)ssnprintf(command, sizeof(command),
+ command_len = (size_t)snprintf(command, sizeof(command),
"PUTVAL %s interval=%.3f %s\r\n", key,
CDTIME_T_TO_DOUBLE(vl->interval), values);
if (command_len >= sizeof(command)) {
/* Nulls the buffer and sets ..._free and ..._fill. */
wh_reset_buffer(cb);
- ssnprintf(callback_name, sizeof(callback_name), "write_http/%s", cb->name);
+ snprintf(callback_name, sizeof(callback_name), "write_http/%s", cb->name);
DEBUG("write_http: Registering write callback '%s' with URL '%s'",
callback_name, cb->location);
#define KAFKA_RANDOM_KEY_BUFFER \
(char[KAFKA_RANDOM_KEY_SIZE]) { "" }
static char *kafka_random_key(char buffer[static KAFKA_RANDOM_KEY_SIZE]) {
- ssnprintf(buffer, KAFKA_RANDOM_KEY_SIZE, "%08" PRIX32, cdrand_u());
+ snprintf(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);
- ssnprintf(callback_name, sizeof(callback_name), "write_kafka/%s",
+ snprintf(callback_name, sizeof(callback_name), "write_kafka/%s",
tctx->topic_name);
status = plugin_register_write(
for (int i = 0; i < ds->ds_num; i++) {
char key[16];
- ssnprintf(key, sizeof(key), "%i", i);
+ snprintf(key, sizeof(key), "%i", i);
if (ds->ds[i].type == DS_TYPE_GAUGE)
BSON_APPEND_DOUBLE(&subarray, key, vl->values[i].gauge);
for (int i = 0; i < ds->ds_num; i++) {
char key[16];
- ssnprintf(key, sizeof(key), "%i", i);
+ snprintf(key, sizeof(key), "%i", i);
if (store_rates)
BSON_APPEND_UTF8(&subarray, key, "gauge");
for (int i = 0; i < ds->ds_num; i++) {
char key[16];
- ssnprintf(key, sizeof(key), "%i", i);
+ snprintf(key, sizeof(key), "%i", i);
BSON_APPEND_UTF8(&subarray, key, ds->ds[i].name);
}
bson_append_array_end(ret, &subarray); /* }}} dsnames */
if (status == 0) {
char cb_name[DATA_MAX_NAME_LEN];
- ssnprintf(cb_name, sizeof(cb_name), "write_mongodb/%s", node->name);
+ snprintf(cb_name, sizeof(cb_name), "write_mongodb/%s", node->name);
status =
plugin_register_write(cb_name, wm_write,
* know that they are sane. */
for (size_t i = 0; i < m->n_label; i++) {
char value[LABEL_VALUE_SIZE];
- ssnprintf(labels[i], LABEL_BUFFER_SIZE, "%s=\"%s\"", m->label[i]->name,
+ snprintf(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? */
- ssnprintf(line, sizeof(line), "# HELP %s %s\n", fam->name, fam->help);
+ snprintf(line, sizeof(line), "# HELP %s %s\n", fam->name, fam->help);
buffer->append(buffer, strlen(line), (uint8_t *)line);
- ssnprintf(line, sizeof(line), "# TYPE %s %s\n", fam->name,
+ snprintf(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)
- ssnprintf(timestamp_ms, sizeof(timestamp_ms), " %" PRIi64,
+ snprintf(timestamp_ms, sizeof(timestamp_ms), " %" PRIi64,
m->timestamp_ms);
if (fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__GAUGE)
- ssnprintf(line, sizeof(line), "%s{%s} " GAUGE_FORMAT "%s\n", fam->name,
+ snprintf(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) */
- ssnprintf(line, sizeof(line), "%s{%s} %.0f%s\n", fam->name,
+ snprintf(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];
- ssnprintf(server, sizeof(server), "\n# collectd/write_prometheus %s at %s\n",
+ snprintf(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];
- ssnprintf(
+ snprintf(
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),
status = FORMAT_VL(ident, sizeof(ident), vl);
if (status != 0)
return status;
- ssnprintf(key, sizeof(key), "%s%s",
+ snprintf(key, sizeof(key), "%s%s",
(node->prefix != NULL) ? node->prefix : REDIS_DEFAULT_PREFIX,
ident);
- ssnprintf(time, sizeof(time), "%.9f", CDTIME_T_TO_DOUBLE(vl->time));
+ snprintf(time, sizeof(time), "%.9f", CDTIME_T_TO_DOUBLE(vl->time));
value_size = sizeof(value);
value_ptr = &value[0];
if (status == 0) {
char cb_name[DATA_MAX_NAME_LEN];
- ssnprintf(cb_name, sizeof(cb_name), "write_redis/%s", node->name);
+ snprintf(cb_name, sizeof(cb_name), "write_redis/%s", node->name);
status = plugin_register_write(
cb_name, wr_write, &(user_data_t){
vl->type_instance);
if (host->always_append_ds || (ds->ds_num > 1)) {
if (host->event_service_prefix == NULL)
- ssnprintf(service_buffer, sizeof(service_buffer), "%s/%s",
+ snprintf(service_buffer, sizeof(service_buffer), "%s/%s",
&name_buffer[1], ds->ds[index].name);
else
- ssnprintf(service_buffer, sizeof(service_buffer), "%s%s/%s",
+ snprintf(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
- ssnprintf(service_buffer, sizeof(service_buffer), "%s%s",
+ snprintf(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];
- ssnprintf(ds_type, sizeof(ds_type), "%s:rate",
+ snprintf(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];
- ssnprintf(ds_index, sizeof(ds_index), "%zu", index);
+ snprintf(ds_index, sizeof(ds_index), "%zu", index);
riemann_event_string_attribute_add(event, "ds_index", ds_index);
}
return status;
}
- ssnprintf(callback_name, sizeof(callback_name), "write_riemann/%s",
+ snprintf(callback_name, sizeof(callback_name), "write_riemann/%s",
host->name);
user_data_t ud = {.data = host, .free_func = wrr_free};
// incorporate the data source type
if ((ds->ds[index].type != DS_TYPE_GAUGE) && (rates != NULL)) {
char ds_type[DATA_MAX_NAME_LEN];
- ssnprintf(ds_type, sizeof(ds_type), "%s:rate",
+ snprintf(ds_type, sizeof(ds_type), "%s:rate",
DS_TYPE_TO_STRING(ds->ds[index].type));
res = my_asprintf(&temp_str, "%s, \"collectd_data_source_type\": \"%s\"",
ret_str, ds_type);
// incorporate the data source index
{
char ds_index[DATA_MAX_NAME_LEN];
- ssnprintf(ds_index, sizeof(ds_index), "%zu", index);
+ snprintf(ds_index, sizeof(ds_index), "%zu", index);
res = my_asprintf(&temp_str, "%s, \"collectd_data_source_index\": %s",
ret_str, ds_index);
free(ret_str);
host->separator);
if (host->always_append_ds || (ds->ds_num > 1)) {
if (host->event_service_prefix == NULL)
- ssnprintf(service_buffer, sizeof(service_buffer), "%s.%s", name_buffer,
+ snprintf(service_buffer, sizeof(service_buffer), "%s.%s", name_buffer,
ds->ds[index].name);
else
- ssnprintf(service_buffer, sizeof(service_buffer), "%s%s.%s",
+ snprintf(service_buffer, sizeof(service_buffer), "%s%s.%s",
host->event_service_prefix, name_buffer, ds->ds[index].name);
} else {
if (host->event_service_prefix == NULL)
sstrncpy(service_buffer, name_buffer, sizeof(service_buffer));
else
- ssnprintf(service_buffer, sizeof(service_buffer), "%s%s",
+ snprintf(service_buffer, sizeof(service_buffer), "%s%s",
host->event_service_prefix, name_buffer);
}
return -1;
}
- ssnprintf(callback_name, sizeof(callback_name), "write_sensu/%s", host->name);
+ snprintf(callback_name, sizeof(callback_name), "write_sensu/%s", host->name);
user_data_t ud = {.data = host, .free_func = sensu_free};
#define BUFFER_ADD(...) \
do { \
- status = ssnprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
+ status = snprintf(ret + offset, ret_len - offset, __VA_ARGS__); \
if (status < 1) { \
sfree(rates); \
return -1; \
if (ds_name != NULL) {
if (vl->plugin_instance[0] == '\0') {
if (vl->type_instance[0] == '\0') {
- ssnprintf(ret, ret_len, "%s%s.%s.%s", prefix, vl->plugin, vl->type,
+ snprintf(ret, ret_len, "%s%s.%s.%s", prefix, vl->plugin, vl->type,
ds_name);
} else {
- ssnprintf(ret, ret_len, "%s%s.%s.%s.%s", prefix, vl->plugin, vl->type,
+ snprintf(ret, ret_len, "%s%s.%s.%s.%s", prefix, vl->plugin, vl->type,
vl->type_instance, ds_name);
}
} else { /* vl->plugin_instance != "" */
if (vl->type_instance[0] == '\0') {
- ssnprintf(ret, ret_len, "%s%s.%s.%s.%s", prefix, vl->plugin,
+ snprintf(ret, ret_len, "%s%s.%s.%s.%s", prefix, vl->plugin,
vl->plugin_instance, vl->type, ds_name);
} else {
- ssnprintf(ret, ret_len, "%s%s.%s.%s.%s.%s", prefix, vl->plugin,
+ snprintf(ret, ret_len, "%s%s.%s.%s.%s.%s", prefix, vl->plugin,
vl->plugin_instance, vl->type, vl->type_instance, ds_name);
}
}
} else { /* ds_name == NULL */
if (vl->plugin_instance[0] == '\0') {
if (vl->type_instance[0] == '\0') {
- ssnprintf(ret, ret_len, "%s%s.%s", prefix, vl->plugin, vl->type);
+ snprintf(ret, ret_len, "%s%s.%s", prefix, vl->plugin, vl->type);
} else {
- ssnprintf(ret, ret_len, "%s%s.%s.%s", prefix, vl->plugin,
+ snprintf(ret, ret_len, "%s%s.%s.%s", prefix, vl->plugin,
vl->type_instance, vl->type);
}
} else { /* vl->plugin_instance != "" */
if (vl->type_instance[0] == '\0') {
- ssnprintf(ret, ret_len, "%s%s.%s.%s", prefix, vl->plugin,
+ snprintf(ret, ret_len, "%s%s.%s.%s", prefix, vl->plugin,
vl->plugin_instance, vl->type);
} else {
- ssnprintf(ret, ret_len, "%s%s.%s.%s.%s", prefix, vl->plugin,
+ snprintf(ret, ret_len, "%s%s.%s.%s.%s", prefix, vl->plugin,
vl->plugin_instance, vl->type, vl->type_instance);
}
}
}
status =
- ssnprintf(message, sizeof(message), "put %s %.0f %s fqdn=%s %s %s\r\n",
+ snprintf(message, sizeof(message), "put %s %.0f %s fqdn=%s %s %s\r\n",
key, CDTIME_T_TO_DOUBLE(time), value, host, tags, host_tags);
sfree(temp);
if (status < 0)
}
}
- ssnprintf(callback_name, sizeof(callback_name), "write_tsdb/%s/%s",
+ snprintf(callback_name, sizeof(callback_name), "write_tsdb/%s/%s",
cb->node != NULL ? cb->node : WT_DEFAULT_NODE,
cb->service != NULL ? cb->service : WT_DEFAULT_SERVICE);
sstrncpy(vl.type_instance, "load", sizeof(vl.type_instance));
if (cpu_num >= 0) {
- ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
+ snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", cpu_num);
}
plugin_dispatch_values(&vl);
} /* static void submit_value */
size_t valuelen = sizeof(value);
int rv;
- ssnprintf(buffer, sizeof(buffer), "%s%s", zfs_arcstat, name);
+ snprintf(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