summaryrefslogtreecommitdiffstats
path: root/plugins/utils.c
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/utils.c')
-rw-r--r--plugins/utils.c551
1 files changed, 198 insertions, 353 deletions
diff --git a/plugins/utils.c b/plugins/utils.c
index 77d6a6f9..09649429 100644
--- a/plugins/utils.c
+++ b/plugins/utils.c
@@ -1,26 +1,26 @@
1/***************************************************************************** 1/*****************************************************************************
2* 2 *
3* Library of useful functions for plugins 3 * Library of useful functions for plugins
4* 4 *
5* License: GPL 5 * License: GPL
6* Copyright (c) 2000 Karl DeBisschop (karl@debisschop.net) 6 * Copyright (c) 2000 Karl DeBisschop (karl@debisschop.net)
7* Copyright (c) 2002-2007 Monitoring Plugins Development Team 7 * Copyright (c) 2002-2024 Monitoring Plugins Development Team
8* 8 *
9* This program is free software: you can redistribute it and/or modify 9 * This program is free software: you can redistribute it and/or modify
10* it under the terms of the GNU General Public License as published by 10 * it under the terms of the GNU General Public License as published by
11* the Free Software Foundation, either version 3 of the License, or 11 * the Free Software Foundation, either version 3 of the License, or
12* (at your option) any later version. 12 * (at your option) any later version.
13* 13 *
14* This program is distributed in the hope that it will be useful, 14 * This program is distributed in the hope that it will be useful,
15* but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17* GNU General Public License for more details. 17 * GNU General Public License for more details.
18* 18 *
19* You should have received a copy of the GNU General Public License 19 * You should have received a copy of the GNU General Public License
20* along with this program. If not, see <http://www.gnu.org/licenses/>. 20 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21* 21 *
22* 22 *
23*****************************************************************************/ 23 *****************************************************************************/
24 24
25#include "common.h" 25#include "common.h"
26#include "./utils.h" 26#include "./utils.h"
@@ -34,7 +34,7 @@
34 34
35#include <arpa/inet.h> 35#include <arpa/inet.h>
36 36
37extern void print_usage (void); 37extern void print_usage(void);
38extern const char *progname; 38extern const char *progname;
39 39
40#define STRLEN 64 40#define STRLEN 64
@@ -42,173 +42,109 @@ extern const char *progname;
42 42
43time_t start_time, end_time; 43time_t start_time, end_time;
44 44
45/* ************************************************************************** 45void usage(const char *msg) {
46 * max_state(STATE_x, STATE_y) 46 printf("%s\n", msg);
47 * compares STATE_x to STATE_y and returns result based on the following 47 print_usage();
48 * STATE_UNKNOWN < STATE_OK < STATE_WARNING < STATE_CRITICAL 48 exit(STATE_UNKNOWN);
49 *
50 * Note that numerically the above does not hold
51 ****************************************************************************/
52
53int
54max_state (int a, int b)
55{
56 if (a == STATE_CRITICAL || b == STATE_CRITICAL)
57 return STATE_CRITICAL;
58 else if (a == STATE_WARNING || b == STATE_WARNING)
59 return STATE_WARNING;
60 else if (a == STATE_OK || b == STATE_OK)
61 return STATE_OK;
62 else if (a == STATE_UNKNOWN || b == STATE_UNKNOWN)
63 return STATE_UNKNOWN;
64 else if (a == STATE_DEPENDENT || b == STATE_DEPENDENT)
65 return STATE_DEPENDENT;
66 else
67 return max (a, b);
68}
69
70/* **************************************************************************
71 * max_state_alt(STATE_x, STATE_y)
72 * compares STATE_x to STATE_y and returns result based on the following
73 * STATE_OK < STATE_DEPENDENT < STATE_UNKNOWN < STATE_WARNING < STATE_CRITICAL
74 *
75 * The main difference between max_state_alt and max_state it that it doesn't
76 * allow setting a default to UNKNOWN. It will instead prioritixe any valid
77 * non-OK state.
78 ****************************************************************************/
79
80int
81max_state_alt (int a, int b)
82{
83 if (a == STATE_CRITICAL || b == STATE_CRITICAL)
84 return STATE_CRITICAL;
85 else if (a == STATE_WARNING || b == STATE_WARNING)
86 return STATE_WARNING;
87 else if (a == STATE_UNKNOWN || b == STATE_UNKNOWN)
88 return STATE_UNKNOWN;
89 else if (a == STATE_DEPENDENT || b == STATE_DEPENDENT)
90 return STATE_DEPENDENT;
91 else if (a == STATE_OK || b == STATE_OK)
92 return STATE_OK;
93 else
94 return max (a, b);
95}
96
97void usage (const char *msg)
98{
99 printf ("%s\n", msg);
100 print_usage ();
101 exit (STATE_UNKNOWN);
102} 49}
103 50
104void usage_va (const char *fmt, ...) 51void usage_va(const char *fmt, ...) {
105{
106 va_list ap; 52 va_list ap;
107 printf("%s: ", progname); 53 printf("%s: ", progname);
108 va_start(ap, fmt); 54 va_start(ap, fmt);
109 vprintf(fmt, ap); 55 vprintf(fmt, ap);
110 va_end(ap); 56 va_end(ap);
111 printf("\n"); 57 printf("\n");
112 exit (STATE_UNKNOWN); 58 exit(STATE_UNKNOWN);
113} 59}
114 60
115void usage2(const char *msg, const char *arg) 61void usage2(const char *msg, const char *arg) {
116{ 62 printf("%s: %s - %s\n", progname, msg, arg ? arg : "(null)");
117 printf ("%s: %s - %s\n", progname, msg, arg?arg:"(null)" ); 63 print_usage();
118 print_usage (); 64 exit(STATE_UNKNOWN);
119 exit (STATE_UNKNOWN);
120} 65}
121 66
122void 67void usage3(const char *msg, int arg) {
123usage3 (const char *msg, int arg) 68 printf("%s: %s - %c\n", progname, msg, arg);
124{
125 printf ("%s: %s - %c\n", progname, msg, arg);
126 print_usage(); 69 print_usage();
127 exit (STATE_UNKNOWN); 70 exit(STATE_UNKNOWN);
128} 71}
129 72
130void 73void usage4(const char *msg) {
131usage4 (const char *msg) 74 printf("%s: %s\n", progname, msg);
132{
133 printf ("%s: %s\n", progname, msg);
134 print_usage(); 75 print_usage();
135 exit (STATE_UNKNOWN); 76 exit(STATE_UNKNOWN);
136} 77}
137 78
138void 79void usage5(void) {
139usage5 (void)
140{
141 print_usage(); 80 print_usage();
142 exit (STATE_UNKNOWN); 81 exit(STATE_UNKNOWN);
143} 82}
144 83
145void 84void print_revision(const char *command_name, const char *revision) {
146print_revision (const char *command_name, const char *revision) 85 printf("%s v%s (%s %s)\n", command_name, revision, PACKAGE, VERSION);
147{
148 printf ("%s v%s (%s %s)\n",
149 command_name, revision, PACKAGE, VERSION);
150} 86}
151 87
152bool is_numeric (char *number) { 88bool is_numeric(char *number) {
153 char tmp[1]; 89 char tmp[1];
154 float x; 90 float x;
155 91
156 if (!number) 92 if (!number)
157 return false; 93 return false;
158 else if (sscanf (number, "%f%c", &x, tmp) == 1) 94 else if (sscanf(number, "%f%c", &x, tmp) == 1)
159 return true; 95 return true;
160 else 96 else
161 return false; 97 return false;
162} 98}
163 99
164bool is_positive (char *number) { 100bool is_positive(char *number) {
165 if (is_numeric (number) && atof (number) > 0.0) 101 if (is_numeric(number) && atof(number) > 0.0)
166 return true; 102 return true;
167 else 103 else
168 return false; 104 return false;
169} 105}
170 106
171bool is_negative (char *number) { 107bool is_negative(char *number) {
172 if (is_numeric (number) && atof (number) < 0.0) 108 if (is_numeric(number) && atof(number) < 0.0)
173 return true; 109 return true;
174 else 110 else
175 return false; 111 return false;
176} 112}
177 113
178bool is_nonnegative (char *number) { 114bool is_nonnegative(char *number) {
179 if (is_numeric (number) && atof (number) >= 0.0) 115 if (is_numeric(number) && atof(number) >= 0.0)
180 return true; 116 return true;
181 else 117 else
182 return false; 118 return false;
183} 119}
184 120
185bool is_percentage (char *number) { 121bool is_percentage(char *number) {
186 int x; 122 int x;
187 if (is_numeric (number) && (x = atof (number)) >= 0 && x <= 100) 123 if (is_numeric(number) && (x = atof(number)) >= 0 && x <= 100)
188 return true; 124 return true;
189 else 125 else
190 return false; 126 return false;
191} 127}
192 128
193bool is_percentage_expression (const char str[]) { 129bool is_percentage_expression(const char str[]) {
194 if (!str) { 130 if (!str) {
195 return false; 131 return false;
196 } 132 }
197 133
198 size_t len = strlen(str); 134 size_t len = strlen(str);
199 135
200 if (str[len-1] != '%') { 136 if (str[len - 1] != '%') {
201 return false; 137 return false;
202 } 138 }
203 139
204 char *foo = calloc(sizeof(char), len + 1); 140 char *foo = calloc(len + 1, sizeof(char));
205 141
206 if (!foo) { 142 if (!foo) {
207 die (STATE_UNKNOWN, _("calloc failed \n")); 143 die(STATE_UNKNOWN, _("calloc failed \n"));
208 } 144 }
209 145
210 strcpy(foo, str); 146 strcpy(foo, str);
211 foo[len-1] = '\0'; 147 foo[len - 1] = '\0';
212 148
213 bool result = is_numeric(foo); 149 bool result = is_numeric(foo);
214 150
@@ -217,13 +153,13 @@ bool is_percentage_expression (const char str[]) {
217 return result; 153 return result;
218} 154}
219 155
220bool is_integer (char *number) { 156bool is_integer(char *number) {
221 long int n; 157 long int n;
222 158
223 if (!number || (strspn (number, "-0123456789 ") != strlen (number))) 159 if (!number || (strspn(number, "-0123456789 ") != strlen(number)))
224 return false; 160 return false;
225 161
226 n = strtol (number, NULL, 10); 162 n = strtol(number, NULL, 10);
227 163
228 if (errno != ERANGE && n >= INT_MIN && n <= INT_MAX) 164 if (errno != ERANGE && n >= INT_MIN && n <= INT_MAX)
229 return true; 165 return true;
@@ -231,22 +167,22 @@ bool is_integer (char *number) {
231 return false; 167 return false;
232} 168}
233 169
234bool is_intpos (char *number) { 170bool is_intpos(char *number) {
235 if (is_integer (number) && atoi (number) > 0) 171 if (is_integer(number) && atoi(number) > 0)
236 return true; 172 return true;
237 else 173 else
238 return false; 174 return false;
239} 175}
240 176
241bool is_intneg (char *number) { 177bool is_intneg(char *number) {
242 if (is_integer (number) && atoi (number) < 0) 178 if (is_integer(number) && atoi(number) < 0)
243 return true; 179 return true;
244 else 180 else
245 return false; 181 return false;
246} 182}
247 183
248bool is_intnonneg (char *number) { 184bool is_intnonneg(char *number) {
249 if (is_integer (number) && atoi (number) >= 0) 185 if (is_integer(number) && atoi(number) >= 0)
250 return true; 186 return true;
251 else 187 else
252 return false; 188 return false;
@@ -259,7 +195,7 @@ bool is_intnonneg (char *number) {
259 */ 195 */
260bool is_int64(char *number, int64_t *target) { 196bool is_int64(char *number, int64_t *target) {
261 errno = 0; 197 errno = 0;
262 char *endptr = { 0 }; 198 char *endptr = {0};
263 199
264 int64_t tmp = strtoll(number, &endptr, 10); 200 int64_t tmp = strtoll(number, &endptr, 10);
265 if (errno != 0) { 201 if (errno != 0) {
@@ -287,7 +223,7 @@ bool is_int64(char *number, int64_t *target) {
287 */ 223 */
288bool is_uint64(char *number, uint64_t *target) { 224bool is_uint64(char *number, uint64_t *target) {
289 errno = 0; 225 errno = 0;
290 char *endptr = { 0 }; 226 char *endptr = {0};
291 unsigned long long tmp = strtoull(number, &endptr, 10); 227 unsigned long long tmp = strtoull(number, &endptr, 10);
292 228
293 if (errno != 0) { 229 if (errno != 0) {
@@ -309,66 +245,50 @@ bool is_uint64(char *number, uint64_t *target) {
309 return true; 245 return true;
310} 246}
311 247
312bool is_intpercent (char *number) { 248bool is_intpercent(char *number) {
313 int i; 249 int i;
314 if (is_integer (number) && (i = atoi (number)) >= 0 && i <= 100) 250 if (is_integer(number) && (i = atoi(number)) >= 0 && i <= 100)
315 return true; 251 return true;
316 else 252 else
317 return false; 253 return false;
318} 254}
319 255
320bool is_option (char *str) { 256bool is_option(char *str) {
321 if (!str) 257 if (!str)
322 return false; 258 return false;
323 else if (strspn (str, "-") == 1 || strspn (str, "-") == 2) 259 else if (strspn(str, "-") == 1 || strspn(str, "-") == 2)
324 return true; 260 return true;
325 else 261 else
326 return false; 262 return false;
327} 263}
328 264
329#ifdef NEED_GETTIMEOFDAY 265#ifdef NEED_GETTIMEOFDAY
330int 266int gettimeofday(struct timeval *tv, struct timezone *tz) {
331gettimeofday (struct timeval *tv, struct timezone *tz)
332{
333 tv->tv_usec = 0; 267 tv->tv_usec = 0;
334 tv->tv_sec = (long) time ((time_t) 0); 268 tv->tv_sec = (long)time((time_t)0);
335} 269}
336#endif 270#endif
337 271
338 272double delta_time(struct timeval tv) {
339
340double
341delta_time (struct timeval tv)
342{
343 struct timeval now; 273 struct timeval now;
344 274
345 gettimeofday (&now, NULL); 275 gettimeofday(&now, NULL);
346 return ((double)(now.tv_sec - tv.tv_sec) + (double)(now.tv_usec - tv.tv_usec) / (double)1000000); 276 return ((double)(now.tv_sec - tv.tv_sec) + (double)(now.tv_usec - tv.tv_usec) / (double)1000000);
347} 277}
348 278
349 279long deltime(struct timeval tv) {
350
351long
352deltime (struct timeval tv)
353{
354 struct timeval now; 280 struct timeval now;
355 gettimeofday (&now, NULL); 281 gettimeofday(&now, NULL);
356 return (now.tv_sec - tv.tv_sec)*1000000 + now.tv_usec - tv.tv_usec; 282 return (now.tv_sec - tv.tv_sec) * 1000000 + now.tv_usec - tv.tv_usec;
357} 283}
358 284
359 285void strip(char *buffer) {
360
361
362void
363strip (char *buffer)
364{
365 size_t x; 286 size_t x;
366 int i; 287 int i;
367 288
368 for (x = strlen (buffer); x >= 1; x--) { 289 for (x = strlen(buffer); x >= 1; x--) {
369 i = x - 1; 290 i = x - 1;
370 if (buffer[i] == ' ' || 291 if (buffer[i] == ' ' || buffer[i] == '\r' || buffer[i] == '\n' || buffer[i] == '\t')
371 buffer[i] == '\r' || buffer[i] == '\n' || buffer[i] == '\t')
372 buffer[i] = '\0'; 292 buffer[i] = '\0';
373 else 293 else
374 break; 294 break;
@@ -376,7 +296,6 @@ strip (char *buffer)
376 return; 296 return;
377} 297}
378 298
379
380/****************************************************************************** 299/******************************************************************************
381 * 300 *
382 * Copies one string to another. Any previously existing data in 301 * Copies one string to another. Any previously existing data in
@@ -389,19 +308,15 @@ strip (char *buffer)
389 * 308 *
390 *****************************************************************************/ 309 *****************************************************************************/
391 310
392char * 311char *strscpy(char *dest, const char *src) {
393strscpy (char *dest, const char *src)
394{
395 if (src == NULL) 312 if (src == NULL)
396 return NULL; 313 return NULL;
397 314
398 xasprintf (&dest, "%s", src); 315 xasprintf(&dest, "%s", src);
399 316
400 return dest; 317 return dest;
401} 318}
402 319
403
404
405/****************************************************************************** 320/******************************************************************************
406 * 321 *
407 * Returns a pointer to the next line of a multiline string buffer 322 * Returns a pointer to the next line of a multiline string buffer
@@ -418,7 +333,7 @@ strscpy (char *dest, const char *src)
418 * This 333 * This
419 * is 334 * is
420 * a 335 * a
421 * 336 *
422 * multiline string buffer 337 * multiline string buffer
423 * ============================== 338 * ==============================
424 * 339 *
@@ -431,7 +346,7 @@ strscpy (char *dest, const char *src)
431 * printf("%d %s",i++,firstword(ptr)); 346 * printf("%d %s",i++,firstword(ptr));
432 * ptr = strnl(ptr); 347 * ptr = strnl(ptr);
433 * } 348 * }
434 * 349 *
435 * Produces the following: 350 * Produces the following:
436 * 351 *
437 * 1 This 352 * 1 This
@@ -452,25 +367,22 @@ strscpy (char *dest, const char *src)
452 * 367 *
453 *****************************************************************************/ 368 *****************************************************************************/
454 369
455char * 370char *strnl(char *str) {
456strnl (char *str)
457{
458 size_t len; 371 size_t len;
459 if (str == NULL) 372 if (str == NULL)
460 return NULL; 373 return NULL;
461 str = strpbrk (str, "\r\n"); 374 str = strpbrk(str, "\r\n");
462 if (str == NULL) 375 if (str == NULL)
463 return NULL; 376 return NULL;
464 len = strspn (str, "\r\n"); 377 len = strspn(str, "\r\n");
465 if (str[len] == '\0') 378 if (str[len] == '\0')
466 return NULL; 379 return NULL;
467 str += len; 380 str += len;
468 if (strlen (str) == 0) 381 if (strlen(str) == 0)
469 return NULL; 382 return NULL;
470 return str; 383 return str;
471} 384}
472 385
473
474/****************************************************************************** 386/******************************************************************************
475 * 387 *
476 * Like strscpy, except only the portion of the source string up to 388 * Like strscpy, except only the portion of the source string up to
@@ -487,29 +399,25 @@ strnl (char *str)
487 * 399 *
488 *****************************************************************************/ 400 *****************************************************************************/
489 401
490char * 402char *strpcpy(char *dest, const char *src, const char *str) {
491strpcpy (char *dest, const char *src, const char *str)
492{
493 size_t len; 403 size_t len;
494 404
495 if (src) 405 if (src)
496 len = strcspn (src, str); 406 len = strcspn(src, str);
497 else 407 else
498 return NULL; 408 return NULL;
499 409
500 if (dest == NULL || strlen (dest) < len) 410 if (dest == NULL || strlen(dest) < len)
501 dest = realloc (dest, len + 1); 411 dest = realloc(dest, len + 1);
502 if (dest == NULL) 412 if (dest == NULL)
503 die (STATE_UNKNOWN, _("failed realloc in strpcpy\n")); 413 die(STATE_UNKNOWN, _("failed realloc in strpcpy\n"));
504 414
505 strncpy (dest, src, len); 415 strncpy(dest, src, len);
506 dest[len] = '\0'; 416 dest[len] = '\0';
507 417
508 return dest; 418 return dest;
509} 419}
510 420
511
512
513/****************************************************************************** 421/******************************************************************************
514 * 422 *
515 * Like strscat, except only the portion of the source string up to 423 * Like strscat, except only the portion of the source string up to
@@ -518,62 +426,54 @@ strpcpy (char *dest, const char *src, const char *str)
518 * str = strpcpy(str,"This is a line of text with no trailing newline","x"); 426 * str = strpcpy(str,"This is a line of text with no trailing newline","x");
519 * str = strpcat(str,"This is a line of text with no trailing newline","x"); 427 * str = strpcat(str,"This is a line of text with no trailing newline","x");
520 * printf("%s\n",str); 428 * printf("%s\n",str);
521 * 429 *
522 *This is a line of texThis is a line of tex 430 *This is a line of texThis is a line of tex
523 * 431 *
524 *****************************************************************************/ 432 *****************************************************************************/
525 433
526char * 434char *strpcat(char *dest, const char *src, const char *str) {
527strpcat (char *dest, const char *src, const char *str)
528{
529 size_t len, l2; 435 size_t len, l2;
530 436
531 if (dest) 437 if (dest)
532 len = strlen (dest); 438 len = strlen(dest);
533 else 439 else
534 len = 0; 440 len = 0;
535 441
536 if (src) { 442 if (src) {
537 l2 = strcspn (src, str); 443 l2 = strcspn(src, str);
538 } 444 } else {
539 else {
540 return dest; 445 return dest;
541 } 446 }
542 447
543 dest = realloc (dest, len + l2 + 1); 448 dest = realloc(dest, len + l2 + 1);
544 if (dest == NULL) 449 if (dest == NULL)
545 die (STATE_UNKNOWN, _("failed malloc in strscat\n")); 450 die(STATE_UNKNOWN, _("failed malloc in strscat\n"));
546 451
547 strncpy (dest + len, src, l2); 452 strncpy(dest + len, src, l2);
548 dest[len + l2] = '\0'; 453 dest[len + l2] = '\0';
549 454
550 return dest; 455 return dest;
551} 456}
552 457
553
554/****************************************************************************** 458/******************************************************************************
555 * 459 *
556 * asprintf, but die on failure 460 * asprintf, but die on failure
557 * 461 *
558 ******************************************************************************/ 462 ******************************************************************************/
559 463
560int 464int xvasprintf(char **strp, const char *fmt, va_list ap) {
561xvasprintf (char **strp, const char *fmt, va_list ap) 465 int result = vasprintf(strp, fmt, ap);
562{
563 int result = vasprintf (strp, fmt, ap);
564 if (result == -1 || *strp == NULL) 466 if (result == -1 || *strp == NULL)
565 die (STATE_UNKNOWN, _("failed malloc in xvasprintf\n")); 467 die(STATE_UNKNOWN, _("failed malloc in xvasprintf\n"));
566 return result; 468 return result;
567} 469}
568 470
569int 471int xasprintf(char **strp, const char *fmt, ...) {
570xasprintf (char **strp, const char *fmt, ...)
571{
572 va_list ap; 472 va_list ap;
573 int result; 473 int result;
574 va_start (ap, fmt); 474 va_start(ap, fmt);
575 result = xvasprintf (strp, fmt, ap); 475 result = xvasprintf(strp, fmt, ap);
576 va_end (ap); 476 va_end(ap);
577 return result; 477 return result;
578} 478}
579 479
@@ -583,247 +483,192 @@ xasprintf (char **strp, const char *fmt, ...)
583 * 483 *
584 ******************************************************************************/ 484 ******************************************************************************/
585 485
586char *perfdata (const char *label, 486char *perfdata(const char *label, long int val, const char *uom, int warnp, long int warn, int critp, long int crit, int minp,
587 long int val, 487 long int minv, int maxp, long int maxv) {
588 const char *uom,
589 int warnp,
590 long int warn,
591 int critp,
592 long int crit,
593 int minp,
594 long int minv,
595 int maxp,
596 long int maxv)
597{
598 char *data = NULL; 488 char *data = NULL;
599 489
600 if (strpbrk (label, "'= ")) 490 if (strpbrk(label, "'= "))
601 xasprintf (&data, "'%s'=%ld%s;", label, val, uom); 491 xasprintf(&data, "'%s'=%ld%s;", label, val, uom);
602 else 492 else
603 xasprintf (&data, "%s=%ld%s;", label, val, uom); 493 xasprintf(&data, "%s=%ld%s;", label, val, uom);
604 494
605 if (warnp) 495 if (warnp)
606 xasprintf (&data, "%s%ld;", data, warn); 496 xasprintf(&data, "%s%ld;", data, warn);
607 else 497 else
608 xasprintf (&data, "%s;", data); 498 xasprintf(&data, "%s;", data);
609 499
610 if (critp) 500 if (critp)
611 xasprintf (&data, "%s%ld;", data, crit); 501 xasprintf(&data, "%s%ld;", data, crit);
612 else 502 else
613 xasprintf (&data, "%s;", data); 503 xasprintf(&data, "%s;", data);
614 504
615 if (minp) 505 if (minp)
616 xasprintf (&data, "%s%ld;", data, minv); 506 xasprintf(&data, "%s%ld;", data, minv);
617 else 507 else
618 xasprintf (&data, "%s;", data); 508 xasprintf(&data, "%s;", data);
619 509
620 if (maxp) 510 if (maxp)
621 xasprintf (&data, "%s%ld", data, maxv); 511 xasprintf(&data, "%s%ld", data, maxv);
622 512
623 return data; 513 return data;
624} 514}
625 515
626 516char *perfdata_uint64(const char *label, uint64_t val, const char *uom, int warnp, /* Warning present */
627char *perfdata_uint64 (const char *label, 517 uint64_t warn, int critp, /* Critical present */
628 uint64_t val, 518 uint64_t crit, int minp, /* Minimum present */
629 const char *uom, 519 uint64_t minv, int maxp, /* Maximum present */
630 int warnp, /* Warning present */ 520 uint64_t maxv) {
631 uint64_t warn,
632 int critp, /* Critical present */
633 uint64_t crit,
634 int minp, /* Minimum present */
635 uint64_t minv,
636 int maxp, /* Maximum present */
637 uint64_t maxv)
638{
639 char *data = NULL; 521 char *data = NULL;
640 522
641 if (strpbrk (label, "'= ")) 523 if (strpbrk(label, "'= "))
642 xasprintf (&data, "'%s'=%" PRIu64 "%s;", label, val, uom); 524 xasprintf(&data, "'%s'=%" PRIu64 "%s;", label, val, uom);
643 else 525 else
644 xasprintf (&data, "%s=%" PRIu64 "%s;", label, val, uom); 526 xasprintf(&data, "%s=%" PRIu64 "%s;", label, val, uom);
645 527
646 if (warnp) 528 if (warnp)
647 xasprintf (&data, "%s%" PRIu64 ";", data, warn); 529 xasprintf(&data, "%s%" PRIu64 ";", data, warn);
648 else 530 else
649 xasprintf (&data, "%s;", data); 531 xasprintf(&data, "%s;", data);
650 532
651 if (critp) 533 if (critp)
652 xasprintf (&data, "%s%" PRIu64 ";", data, crit); 534 xasprintf(&data, "%s%" PRIu64 ";", data, crit);
653 else 535 else
654 xasprintf (&data, "%s;", data); 536 xasprintf(&data, "%s;", data);
655 537
656 if (minp) 538 if (minp)
657 xasprintf (&data, "%s%" PRIu64 ";", data, minv); 539 xasprintf(&data, "%s%" PRIu64 ";", data, minv);
658 else 540 else
659 xasprintf (&data, "%s;", data); 541 xasprintf(&data, "%s;", data);
660 542
661 if (maxp) 543 if (maxp)
662 xasprintf (&data, "%s%" PRIu64, data, maxv); 544 xasprintf(&data, "%s%" PRIu64, data, maxv);
663 545
664 return data; 546 return data;
665} 547}
666 548
667 549char *perfdata_int64(const char *label, int64_t val, const char *uom, int warnp, /* Warning present */
668char *perfdata_int64 (const char *label, 550 int64_t warn, int critp, /* Critical present */
669 int64_t val, 551 int64_t crit, int minp, /* Minimum present */
670 const char *uom, 552 int64_t minv, int maxp, /* Maximum present */
671 int warnp, /* Warning present */ 553 int64_t maxv) {
672 int64_t warn,
673 int critp, /* Critical present */
674 int64_t crit,
675 int minp, /* Minimum present */
676 int64_t minv,
677 int maxp, /* Maximum present */
678 int64_t maxv)
679{
680 char *data = NULL; 554 char *data = NULL;
681 555
682 if (strpbrk (label, "'= ")) 556 if (strpbrk(label, "'= "))
683 xasprintf (&data, "'%s'=%" PRId64 "%s;", label, val, uom); 557 xasprintf(&data, "'%s'=%" PRId64 "%s;", label, val, uom);
684 else 558 else
685 xasprintf (&data, "%s=%" PRId64 "%s;", label, val, uom); 559 xasprintf(&data, "%s=%" PRId64 "%s;", label, val, uom);
686 560
687 if (warnp) 561 if (warnp)
688 xasprintf (&data, "%s%" PRId64 ";", data, warn); 562 xasprintf(&data, "%s%" PRId64 ";", data, warn);
689 else 563 else
690 xasprintf (&data, "%s;", data); 564 xasprintf(&data, "%s;", data);
691 565
692 if (critp) 566 if (critp)
693 xasprintf (&data, "%s%" PRId64 ";", data, crit); 567 xasprintf(&data, "%s%" PRId64 ";", data, crit);
694 else 568 else
695 xasprintf (&data, "%s;", data); 569 xasprintf(&data, "%s;", data);
696 570
697 if (minp) 571 if (minp)
698 xasprintf (&data, "%s%" PRId64 ";", data, minv); 572 xasprintf(&data, "%s%" PRId64 ";", data, minv);
699 else 573 else
700 xasprintf (&data, "%s;", data); 574 xasprintf(&data, "%s;", data);
701 575
702 if (maxp) 576 if (maxp)
703 xasprintf (&data, "%s%" PRId64, data, maxv); 577 xasprintf(&data, "%s%" PRId64, data, maxv);
704 578
705 return data; 579 return data;
706} 580}
707 581
708 582char *fperfdata(const char *label, double val, const char *uom, int warnp, double warn, int critp, double crit, int minp, double minv,
709char *fperfdata (const char *label, 583 int maxp, double maxv) {
710 double val,
711 const char *uom,
712 int warnp,
713 double warn,
714 int critp,
715 double crit,
716 int minp,
717 double minv,
718 int maxp,
719 double maxv)
720{
721 char *data = NULL; 584 char *data = NULL;
722 585
723 if (strpbrk (label, "'= ")) 586 if (strpbrk(label, "'= "))
724 xasprintf (&data, "'%s'=", label); 587 xasprintf(&data, "'%s'=", label);
725 else 588 else
726 xasprintf (&data, "%s=", label); 589 xasprintf(&data, "%s=", label);
727 590
728 xasprintf (&data, "%s%f", data, val); 591 xasprintf(&data, "%s%f", data, val);
729 xasprintf (&data, "%s%s;", data, uom); 592 xasprintf(&data, "%s%s;", data, uom);
730 593
731 if (warnp) 594 if (warnp)
732 xasprintf (&data, "%s%f", data, warn); 595 xasprintf(&data, "%s%f", data, warn);
733 596
734 xasprintf (&data, "%s;", data); 597 xasprintf(&data, "%s;", data);
735 598
736 if (critp) 599 if (critp)
737 xasprintf (&data, "%s%f", data, crit); 600 xasprintf(&data, "%s%f", data, crit);
738 601
739 xasprintf (&data, "%s;", data); 602 xasprintf(&data, "%s;", data);
740 603
741 if (minp) 604 if (minp)
742 xasprintf (&data, "%s%f", data, minv); 605 xasprintf(&data, "%s%f", data, minv);
743 606
744 if (maxp) { 607 if (maxp) {
745 xasprintf (&data, "%s;", data); 608 xasprintf(&data, "%s;", data);
746 xasprintf (&data, "%s%f", data, maxv); 609 xasprintf(&data, "%s%f", data, maxv);
747 } 610 }
748 611
749 return data; 612 return data;
750} 613}
751 614
752char *sperfdata (const char *label, 615char *sperfdata(const char *label, double val, const char *uom, char *warn, char *crit, int minp, double minv, int maxp, double maxv) {
753 double val,
754 const char *uom,
755 char *warn,
756 char *crit,
757 int minp,
758 double minv,
759 int maxp,
760 double maxv)
761{
762 char *data = NULL; 616 char *data = NULL;
763 if (strpbrk (label, "'= ")) 617 if (strpbrk(label, "'= "))
764 xasprintf (&data, "'%s'=", label); 618 xasprintf(&data, "'%s'=", label);
765 else 619 else
766 xasprintf (&data, "%s=", label); 620 xasprintf(&data, "%s=", label);
767 621
768 xasprintf (&data, "%s%f", data, val); 622 xasprintf(&data, "%s%f", data, val);
769 xasprintf (&data, "%s%s;", data, uom); 623 xasprintf(&data, "%s%s;", data, uom);
770 624
771 if (warn!=NULL) 625 if (warn != NULL)
772 xasprintf (&data, "%s%s", data, warn); 626 xasprintf(&data, "%s%s", data, warn);
773 627
774 xasprintf (&data, "%s;", data); 628 xasprintf(&data, "%s;", data);
775 629
776 if (crit!=NULL) 630 if (crit != NULL)
777 xasprintf (&data, "%s%s", data, crit); 631 xasprintf(&data, "%s%s", data, crit);
778 632
779 xasprintf (&data, "%s;", data); 633 xasprintf(&data, "%s;", data);
780 634
781 if (minp) 635 if (minp)
782 xasprintf (&data, "%s%f", data, minv); 636 xasprintf(&data, "%s%f", data, minv);
783 637
784 if (maxp) { 638 if (maxp) {
785 xasprintf (&data, "%s;", data); 639 xasprintf(&data, "%s;", data);
786 xasprintf (&data, "%s%f", data, maxv); 640 xasprintf(&data, "%s%f", data, maxv);
787 } 641 }
788 642
789 return data; 643 return data;
790} 644}
791 645
792char *sperfdata_int (const char *label, 646char *sperfdata_int(const char *label, int val, const char *uom, char *warn, char *crit, int minp, int minv, int maxp, int maxv) {
793 int val,
794 const char *uom,
795 char *warn,
796 char *crit,
797 int minp,
798 int minv,
799 int maxp,
800 int maxv)
801{
802 char *data = NULL; 647 char *data = NULL;
803 if (strpbrk (label, "'= ")) 648 if (strpbrk(label, "'= "))
804 xasprintf (&data, "'%s'=", label); 649 xasprintf(&data, "'%s'=", label);
805 else 650 else
806 xasprintf (&data, "%s=", label); 651 xasprintf(&data, "%s=", label);
807 652
808 xasprintf (&data, "%s%d", data, val); 653 xasprintf(&data, "%s%d", data, val);
809 xasprintf (&data, "%s%s;", data, uom); 654 xasprintf(&data, "%s%s;", data, uom);
810 655
811 if (warn!=NULL) 656 if (warn != NULL)
812 xasprintf (&data, "%s%s", data, warn); 657 xasprintf(&data, "%s%s", data, warn);
813 658
814 xasprintf (&data, "%s;", data); 659 xasprintf(&data, "%s;", data);
815 660
816 if (crit!=NULL) 661 if (crit != NULL)
817 xasprintf (&data, "%s%s", data, crit); 662 xasprintf(&data, "%s%s", data, crit);
818 663
819 xasprintf (&data, "%s;", data); 664 xasprintf(&data, "%s;", data);
820 665
821 if (minp) 666 if (minp)
822 xasprintf (&data, "%s%d", data, minv); 667 xasprintf(&data, "%s%d", data, minv);
823 668
824 if (maxp) { 669 if (maxp) {
825 xasprintf (&data, "%s;", data); 670 xasprintf(&data, "%s;", data);
826 xasprintf (&data, "%s%d", data, maxv); 671 xasprintf(&data, "%s%d", data, maxv);
827 } 672 }
828 673
829 return data; 674 return data;