diff options
Diffstat (limited to 'plugins')
38 files changed, 204 insertions, 316 deletions
diff --git a/plugins/check_dig.c b/plugins/check_dig.c index a44d5786..c6078965 100644 --- a/plugins/check_dig.c +++ b/plugins/check_dig.c | |||
@@ -81,9 +81,9 @@ main (int argc, char **argv) | |||
81 | if (verbose) { | 81 | if (verbose) { |
82 | printf ("%s\n", command_line); | 82 | printf ("%s\n", command_line); |
83 | if(expected_address != NULL) { | 83 | if(expected_address != NULL) { |
84 | printf ("Looking for: '%s'\n", expected_address); | 84 | printf (_("Looking for: '%s'\n"), expected_address); |
85 | } else { | 85 | } else { |
86 | printf ("Looking for: '%s'\n", query_address); | 86 | printf (_("Looking for: '%s'\n"), query_address); |
87 | } | 87 | } |
88 | } | 88 | } |
89 | 89 | ||
@@ -214,9 +214,7 @@ process_arguments (int argc, char **argv) | |||
214 | 214 | ||
215 | switch (c) { | 215 | switch (c) { |
216 | case '?': /* help */ | 216 | case '?': /* help */ |
217 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 217 | usage2 (_("Unknown argument"), optarg); |
218 | print_usage (); | ||
219 | exit (STATE_UNKNOWN); | ||
220 | case 'h': /* help */ | 218 | case 'h': /* help */ |
221 | print_help (); | 219 | print_help (); |
222 | exit (STATE_OK); | 220 | exit (STATE_OK); |
diff --git a/plugins/check_disk.c b/plugins/check_disk.c index 669a1cd6..ab9f66f8 100644 --- a/plugins/check_disk.c +++ b/plugins/check_disk.c | |||
@@ -438,9 +438,7 @@ process_arguments (int argc, char **argv) | |||
438 | print_help (); | 438 | print_help (); |
439 | exit (STATE_OK); | 439 | exit (STATE_OK); |
440 | case '?': /* help */ | 440 | case '?': /* help */ |
441 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 441 | usage2 (_("Unknown argument"), optarg); |
442 | print_usage (); | ||
443 | exit (STATE_UNKNOWN); | ||
444 | } | 442 | } |
445 | } | 443 | } |
446 | 444 | ||
@@ -488,7 +486,7 @@ print_path (const char *mypath) | |||
488 | if (mypath == NULL) | 486 | if (mypath == NULL) |
489 | printf ("\n"); | 487 | printf ("\n"); |
490 | else | 488 | else |
491 | printf (" for %s\n", mypath); | 489 | printf (_(" for %s\n"), mypath); |
492 | 490 | ||
493 | return; | 491 | return; |
494 | } | 492 | } |
diff --git a/plugins/check_dns.c b/plugins/check_dns.c index 20cb6dd8..e6483b9c 100644 --- a/plugins/check_dns.c +++ b/plugins/check_dns.c | |||
@@ -135,7 +135,7 @@ main (int argc, char **argv) | |||
135 | asprintf(&address, "%s,%s", address, temp_buffer); | 135 | asprintf(&address, "%s,%s", address, temp_buffer); |
136 | } | 136 | } |
137 | 137 | ||
138 | else if (strstr (input_buffer, "Non-authoritative answer:")) { | 138 | else if (strstr (input_buffer, _("Non-authoritative answer:"))) { |
139 | non_authoritative = TRUE; | 139 | non_authoritative = TRUE; |
140 | } | 140 | } |
141 | 141 | ||
@@ -277,7 +277,6 @@ error_scan (char *input_buffer) | |||
277 | } | 277 | } |
278 | 278 | ||
279 | 279 | ||
280 | |||
281 | /* process command-line arguments */ | 280 | /* process command-line arguments */ |
282 | int | 281 | int |
283 | process_arguments (int argc, char **argv) | 282 | process_arguments (int argc, char **argv) |
@@ -313,9 +312,7 @@ process_arguments (int argc, char **argv) | |||
313 | 312 | ||
314 | switch (c) { | 313 | switch (c) { |
315 | case '?': /* args not parsable */ | 314 | case '?': /* args not parsable */ |
316 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 315 | usage2 (_("Unknown argument"), optarg); |
317 | print_usage (); | ||
318 | exit (STATE_UNKNOWN); | ||
319 | case 'h': /* help */ | 316 | case 'h': /* help */ |
320 | print_help (); | 317 | print_help (); |
321 | exit (STATE_OK); | 318 | exit (STATE_OK); |
@@ -386,7 +383,6 @@ process_arguments (int argc, char **argv) | |||
386 | } | 383 | } |
387 | 384 | ||
388 | 385 | ||
389 | |||
390 | int | 386 | int |
391 | validate_arguments () | 387 | validate_arguments () |
392 | { | 388 | { |
@@ -397,7 +393,6 @@ validate_arguments () | |||
397 | } | 393 | } |
398 | 394 | ||
399 | 395 | ||
400 | |||
401 | void | 396 | void |
402 | print_help (void) | 397 | print_help (void) |
403 | { | 398 | { |
@@ -432,7 +427,6 @@ specified in /etc/resolv.conf will be used.\n\n")); | |||
432 | } | 427 | } |
433 | 428 | ||
434 | 429 | ||
435 | |||
436 | void | 430 | void |
437 | print_usage (void) | 431 | print_usage (void) |
438 | { | 432 | { |
diff --git a/plugins/check_dummy.c b/plugins/check_dummy.c index 2dbbaec8..08926115 100644 --- a/plugins/check_dummy.c +++ b/plugins/check_dummy.c | |||
@@ -30,7 +30,6 @@ void print_help (void); | |||
30 | void print_usage (void); | 30 | void print_usage (void); |
31 | 31 | ||
32 | 32 | ||
33 | |||
34 | int | 33 | int |
35 | main (int argc, char **argv) | 34 | main (int argc, char **argv) |
36 | { | 35 | { |
diff --git a/plugins/check_fping.c b/plugins/check_fping.c index 7f05d4d5..5ffcd16e 100644 --- a/plugins/check_fping.c +++ b/plugins/check_fping.c | |||
@@ -242,9 +242,7 @@ process_arguments (int argc, char **argv) | |||
242 | 242 | ||
243 | switch (c) { | 243 | switch (c) { |
244 | case '?': /* print short usage statement if args not parsable */ | 244 | case '?': /* print short usage statement if args not parsable */ |
245 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 245 | usage2 (_("Unknown argument"), optarg); |
246 | print_usage (); | ||
247 | exit (STATE_UNKNOWN); | ||
248 | case 'h': /* help */ | 246 | case 'h': /* help */ |
249 | print_help (); | 247 | print_help (); |
250 | exit (STATE_OK); | 248 | exit (STATE_OK); |
@@ -301,15 +299,13 @@ process_arguments (int argc, char **argv) | |||
301 | } | 299 | } |
302 | } | 300 | } |
303 | 301 | ||
304 | |||
305 | if (server_name == NULL) | 302 | if (server_name == NULL) |
306 | usage (_("Hostname was not supplied\n\n")); | 303 | usage4 (_("Hostname was not supplied")); |
307 | 304 | ||
308 | return OK; | 305 | return OK; |
309 | } | 306 | } |
310 | 307 | ||
311 | 308 | ||
312 | |||
313 | int | 309 | int |
314 | get_threshold (char *arg, char *rv[2]) | 310 | get_threshold (char *arg, char *rv[2]) |
315 | { | 311 | { |
@@ -351,7 +347,6 @@ get_threshold (char *arg, char *rv[2]) | |||
351 | } | 347 | } |
352 | 348 | ||
353 | 349 | ||
354 | |||
355 | void | 350 | void |
356 | print_help (void) | 351 | print_help (void) |
357 | { | 352 | { |
@@ -395,7 +390,6 @@ percentage of packet loss to trigger an alarm state.\n")); | |||
395 | } | 390 | } |
396 | 391 | ||
397 | 392 | ||
398 | |||
399 | void | 393 | void |
400 | print_usage (void) | 394 | print_usage (void) |
401 | { | 395 | { |
diff --git a/plugins/check_game.c b/plugins/check_game.c index 6699c71d..05b363af 100644 --- a/plugins/check_game.c +++ b/plugins/check_game.c | |||
@@ -123,15 +123,15 @@ main (int argc, char **argv) | |||
123 | } | 123 | } |
124 | 124 | ||
125 | if (strstr (ret[2], QSTAT_HOST_ERROR)) { | 125 | if (strstr (ret[2], QSTAT_HOST_ERROR)) { |
126 | printf ("CRITICAL - Host not found\n"); | 126 | printf (_("CRITICAL - Host not found\n")); |
127 | result = STATE_CRITICAL; | 127 | result = STATE_CRITICAL; |
128 | } | 128 | } |
129 | else if (strstr (ret[2], QSTAT_HOST_DOWN)) { | 129 | else if (strstr (ret[2], QSTAT_HOST_DOWN)) { |
130 | printf ("CRITICAL - Game server down or unavailable\n"); | 130 | printf (_("CRITICAL - Game server down or unavailable\n")); |
131 | result = STATE_CRITICAL; | 131 | result = STATE_CRITICAL; |
132 | } | 132 | } |
133 | else if (strstr (ret[2], QSTAT_HOST_TIMEOUT)) { | 133 | else if (strstr (ret[2], QSTAT_HOST_TIMEOUT)) { |
134 | printf ("CRITICAL - Game server timeout\n"); | 134 | printf (_("CRITICAL - Game server timeout\n")); |
135 | result = STATE_CRITICAL; | 135 | result = STATE_CRITICAL; |
136 | } | 136 | } |
137 | else { | 137 | else { |
@@ -156,7 +156,6 @@ main (int argc, char **argv) | |||
156 | } | 156 | } |
157 | 157 | ||
158 | 158 | ||
159 | |||
160 | int | 159 | int |
161 | process_arguments (int argc, char **argv) | 160 | process_arguments (int argc, char **argv) |
162 | { | 161 | { |
@@ -199,9 +198,7 @@ process_arguments (int argc, char **argv) | |||
199 | 198 | ||
200 | switch (c) { | 199 | switch (c) { |
201 | case '?': /* args not parsable */ | 200 | case '?': /* args not parsable */ |
202 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 201 | usage2 (_("Unknown argument"), optarg); |
203 | print_usage (); | ||
204 | exit (STATE_UNKNOWN); | ||
205 | case 'h': /* help */ | 202 | case 'h': /* help */ |
206 | print_help (); | 203 | print_help (); |
207 | exit (STATE_OK); | 204 | exit (STATE_OK); |
@@ -269,6 +266,7 @@ process_arguments (int argc, char **argv) | |||
269 | return validate_arguments (); | 266 | return validate_arguments (); |
270 | } | 267 | } |
271 | 268 | ||
269 | |||
272 | int | 270 | int |
273 | validate_arguments (void) | 271 | validate_arguments (void) |
274 | { | 272 | { |
@@ -291,9 +289,6 @@ validate_arguments (void) | |||
291 | } | 289 | } |
292 | 290 | ||
293 | 291 | ||
294 | |||
295 | |||
296 | |||
297 | void | 292 | void |
298 | print_help (void) | 293 | print_help (void) |
299 | { | 294 | { |
diff --git a/plugins/check_hpjd.c b/plugins/check_hpjd.c index 53769565..dd49893b 100644 --- a/plugins/check_hpjd.c +++ b/plugins/check_hpjd.c | |||
@@ -286,7 +286,6 @@ main (int argc, char **argv) | |||
286 | } | 286 | } |
287 | 287 | ||
288 | 288 | ||
289 | |||
290 | /* process command-line arguments */ | 289 | /* process command-line arguments */ |
291 | int | 290 | int |
292 | process_arguments (int argc, char **argv) | 291 | process_arguments (int argc, char **argv) |
@@ -334,9 +333,7 @@ process_arguments (int argc, char **argv) | |||
334 | print_help (); | 333 | print_help (); |
335 | exit (STATE_OK); | 334 | exit (STATE_OK); |
336 | case '?': /* help */ | 335 | case '?': /* help */ |
337 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 336 | usage2 (_("Unknown argument"), optarg); |
338 | print_usage (); | ||
339 | exit (STATE_UNKNOWN); | ||
340 | } | 337 | } |
341 | } | 338 | } |
342 | 339 | ||
@@ -361,7 +358,6 @@ process_arguments (int argc, char **argv) | |||
361 | } | 358 | } |
362 | 359 | ||
363 | 360 | ||
364 | |||
365 | int | 361 | int |
366 | validate_arguments (void) | 362 | validate_arguments (void) |
367 | { | 363 | { |
@@ -369,7 +365,6 @@ validate_arguments (void) | |||
369 | } | 365 | } |
370 | 366 | ||
371 | 367 | ||
372 | |||
373 | void | 368 | void |
374 | print_help (void) | 369 | print_help (void) |
375 | { | 370 | { |
diff --git a/plugins/check_icmp.c b/plugins/check_icmp.c index cbd68642..45716824 100644 --- a/plugins/check_icmp.c +++ b/plugins/check_icmp.c | |||
@@ -310,19 +310,19 @@ int main(int argc, char **argv) | |||
310 | 310 | ||
311 | /* check if we are root */ | 311 | /* check if we are root */ |
312 | if(geteuid()) { | 312 | if(geteuid()) { |
313 | printf("Root access needed (for raw sockets)\n"); | 313 | printf(_("Root access needed (for raw sockets)\n")); |
314 | exit(STATE_UNKNOWN); | 314 | exit(STATE_UNKNOWN); |
315 | } | 315 | } |
316 | 316 | ||
317 | /* confirm that ICMP is available on this machine */ | 317 | /* confirm that ICMP is available on this machine */ |
318 | if((proto = getprotobyname("icmp")) == NULL) | 318 | if((proto = getprotobyname("icmp")) == NULL) |
319 | crash("icmp: unknown protocol"); | 319 | crash(_("icmp: unknown protocol")); |
320 | 320 | ||
321 | /* create raw socket for ICMP calls (ping) */ | 321 | /* create raw socket for ICMP calls (ping) */ |
322 | sock = socket(AF_INET, SOCK_RAW, proto->p_proto); | 322 | sock = socket(AF_INET, SOCK_RAW, proto->p_proto); |
323 | 323 | ||
324 | if(sock < 0) | 324 | if(sock < 0) |
325 | crash("can't create raw socket"); | 325 | crash(_("Can't create raw socket")); |
326 | 326 | ||
327 | /* drop privileges now that we have the socket */ | 327 | /* drop privileges now that we have the socket */ |
328 | if((uid = getuid())) { | 328 | if((uid = getuid())) { |
@@ -334,7 +334,7 @@ int main(int argc, char **argv) | |||
334 | ident = getpid() & 0xFFFF; | 334 | ident = getpid() & 0xFFFF; |
335 | 335 | ||
336 | if(!(host_base_ptr = malloc(sizeof(struct host_name_list)))) { | 336 | if(!(host_base_ptr = malloc(sizeof(struct host_name_list)))) { |
337 | crash("Unable to allocate memory for host name list\n"); | 337 | crash(_("Unable to allocate memory for host name list\n")); |
338 | } | 338 | } |
339 | host_ptr = host_base_ptr; | 339 | host_ptr = host_base_ptr; |
340 | 340 | ||
@@ -359,12 +359,12 @@ int main(int argc, char **argv) | |||
359 | switch (c) { | 359 | switch (c) { |
360 | case 'H': | 360 | case 'H': |
361 | if(!(host_ptr->entry = malloc(strlen(optarg) + 1))) { | 361 | if(!(host_ptr->entry = malloc(strlen(optarg) + 1))) { |
362 | crash("Failed to allocate memory for hostname"); | 362 | crash(_("Failed to allocate memory for hostname")); |
363 | } | 363 | } |
364 | memset(host_ptr->entry, 0, strlen(optarg) + 1); | 364 | memset(host_ptr->entry, 0, strlen(optarg) + 1); |
365 | host_ptr->entry = memcpy(host_ptr->entry, optarg, strlen(optarg)); | 365 | host_ptr->entry = memcpy(host_ptr->entry, optarg, strlen(optarg)); |
366 | if(!(host_ptr->next = malloc(sizeof(struct host_name_list)))) | 366 | if(!(host_ptr->next = malloc(sizeof(struct host_name_list)))) |
367 | crash("Failed to allocate memory for hostname"); | 367 | crash(_("Failed to allocate memory for hostname")); |
368 | host_ptr = host_ptr->next; | 368 | host_ptr = host_ptr->next; |
369 | host_ptr->next = NULL; | 369 | host_ptr->next = NULL; |
370 | // add_name(optarg); | 370 | // add_name(optarg); |
@@ -375,35 +375,35 @@ int main(int argc, char **argv) | |||
375 | break; | 375 | break; |
376 | case 'w': | 376 | case 'w': |
377 | if(get_threshold(optarg, &warn)) { | 377 | if(get_threshold(optarg, &warn)) { |
378 | printf("Illegal threshold pair specified for -%c", c); | 378 | printf(_("Illegal threshold pair specified for -%c"), c); |
379 | print_usage(); | 379 | print_usage(); |
380 | } | 380 | } |
381 | break; | 381 | break; |
382 | 382 | ||
383 | case 'c': | 383 | case 'c': |
384 | if(get_threshold(optarg, &crit)) { | 384 | if(get_threshold(optarg, &crit)) { |
385 | printf("Illegal threshold pair specified for -%c", c); | 385 | printf(_("Illegal threshold pair specified for -%c"), c); |
386 | print_usage(); | 386 | print_usage(); |
387 | } | 387 | } |
388 | break; | 388 | break; |
389 | 389 | ||
390 | case 't': | 390 | case 't': |
391 | if(!(timeout = (u_int) strtoul(optarg, NULL, 0) * 100)) { | 391 | if(!(timeout = (u_int) strtoul(optarg, NULL, 0) * 100)) { |
392 | printf("option -%c requires integer argument\n", c); | 392 | printf(_("Option -%c requires integer argument\n"), c); |
393 | print_usage(); | 393 | print_usage(); |
394 | } | 394 | } |
395 | break; | 395 | break; |
396 | 396 | ||
397 | case 'r': | 397 | case 'r': |
398 | if(!(retry = (u_int) strtoul(optarg, NULL, 0))) { | 398 | if(!(retry = (u_int) strtoul(optarg, NULL, 0))) { |
399 | printf("option -%c requires integer argument\n", c); | 399 | printf(_("Option -%c requires integer argument\n"), c); |
400 | print_usage(); | 400 | print_usage(); |
401 | } | 401 | } |
402 | break; | 402 | break; |
403 | 403 | ||
404 | case 'i': | 404 | case 'i': |
405 | if(!(interval = (u_int) strtoul(optarg, NULL, 0) * 100)) { | 405 | if(!(interval = (u_int) strtoul(optarg, NULL, 0) * 100)) { |
406 | printf("option -%c requires positive non-zero integer argument\n", c); | 406 | printf(_("Option -%c requires positive non-zero integer argument\n"), c); |
407 | print_usage(); | 407 | print_usage(); |
408 | } | 408 | } |
409 | break; | 409 | break; |
@@ -411,14 +411,14 @@ int main(int argc, char **argv) | |||
411 | case 'p': | 411 | case 'p': |
412 | case 'n': | 412 | case 'n': |
413 | if(!(count = (u_int) strtoul(optarg, NULL, 0))) { | 413 | if(!(count = (u_int) strtoul(optarg, NULL, 0))) { |
414 | printf("option -%c requires positive non-zero integer argument\n", c); | 414 | printf(_("Option -%c requires positive non-zero integer argument\n"), c); |
415 | print_usage(); | 415 | print_usage(); |
416 | } | 416 | } |
417 | break; | 417 | break; |
418 | 418 | ||
419 | case 'b': | 419 | case 'b': |
420 | if(!(ping_data_size = (u_int) strtoul(optarg, NULL, 0))) { | 420 | if(!(ping_data_size = (u_int) strtoul(optarg, NULL, 0))) { |
421 | printf("option -%c requires integer argument\n", c); | 421 | printf(_("Option -%c requires integer argument\n"), c); |
422 | print_usage(); | 422 | print_usage(); |
423 | } | 423 | } |
424 | break; | 424 | break; |
@@ -467,7 +467,7 @@ int main(int argc, char **argv) | |||
467 | break; | 467 | break; |
468 | 468 | ||
469 | default: | 469 | default: |
470 | printf("option flag -%c specified, but not recognized\n", c); | 470 | printf(_("Option flag -%c specified, but not recognized\n"), c); |
471 | print_usage(); | 471 | print_usage(); |
472 | break; | 472 | break; |
473 | } | 473 | } |
@@ -494,30 +494,30 @@ int main(int argc, char **argv) | |||
494 | else if(timeout < warn.rta) timeout = warn.rta; | 494 | else if(timeout < warn.rta) timeout = warn.rta; |
495 | 495 | ||
496 | if((interval < MIN_INTERVAL * 100 || retry > MAX_RETRY) && getuid()) { | 496 | if((interval < MIN_INTERVAL * 100 || retry > MAX_RETRY) && getuid()) { |
497 | printf("%s: these options are too risky for mere mortals.\n", prog); | 497 | printf(_("%s: these options are too risky for mere mortals.\n"), prog); |
498 | printf("%s: You need i >= %u and r < %u\n", | 498 | printf(_("%s: You need i >= %u and r < %u\n"), |
499 | prog, MIN_INTERVAL, MAX_RETRY); | 499 | prog, MIN_INTERVAL, MAX_RETRY); |
500 | printf("Current settings; i = %d, r = %d\n", | 500 | printf(_("Current settings; i = %d, r = %d\n"), |
501 | interval / 100, retry); | 501 | interval / 100, retry); |
502 | print_usage(); | 502 | print_usage(); |
503 | } | 503 | } |
504 | 504 | ||
505 | if((ping_data_size > MAX_PING_DATA) || (ping_data_size < MIN_PING_DATA)) { | 505 | if((ping_data_size > MAX_PING_DATA) || (ping_data_size < MIN_PING_DATA)) { |
506 | printf("%s: data size %u not valid, must be between %u and %u\n", | 506 | printf(_("%s: data size %u not valid, must be between %u and %u\n"), |
507 | prog, ping_data_size, MIN_PING_DATA, MAX_PING_DATA); | 507 | prog, ping_data_size, MIN_PING_DATA, MAX_PING_DATA); |
508 | print_usage(); | 508 | print_usage(); |
509 | 509 | ||
510 | } | 510 | } |
511 | 511 | ||
512 | if((backoff > MAX_BACKOFF_FACTOR) || (backoff < MIN_BACKOFF_FACTOR)) { | 512 | if((backoff > MAX_BACKOFF_FACTOR) || (backoff < MIN_BACKOFF_FACTOR)) { |
513 | printf("%s: backoff factor %.1f not valid, must be between %.1f and %.1f\n", | 513 | printf(_("%s: backoff factor %.1f not valid, must be between %.1f and %.1f\n"), |
514 | prog, backoff, MIN_BACKOFF_FACTOR, MAX_BACKOFF_FACTOR); | 514 | prog, backoff, MIN_BACKOFF_FACTOR, MAX_BACKOFF_FACTOR); |
515 | print_usage(); | 515 | print_usage(); |
516 | 516 | ||
517 | } | 517 | } |
518 | 518 | ||
519 | if(count > MAX_COUNT) { | 519 | if(count > MAX_COUNT) { |
520 | printf("%s: count %u not valid, must be less than %u\n", | 520 | printf(_("%s: count %u not valid, must be less than %u\n"), |
521 | prog, count, MAX_COUNT); | 521 | prog, count, MAX_COUNT); |
522 | print_usage(); | 522 | print_usage(); |
523 | } | 523 | } |
@@ -536,19 +536,19 @@ int main(int argc, char **argv) | |||
536 | 536 | ||
537 | /* generate requires command line parameters beyond the switches */ | 537 | /* generate requires command line parameters beyond the switches */ |
538 | if(generate_flag && !*argv) { | 538 | if(generate_flag && !*argv) { |
539 | printf("generate flag requires command line parameters beyond switches\n"); | 539 | printf(_("Generate flag requires command line parameters beyond switches\n")); |
540 | print_usage(); | 540 | print_usage(); |
541 | } | 541 | } |
542 | 542 | ||
543 | if(*argv && !generate_flag) { | 543 | if(*argv && !generate_flag) { |
544 | while(*argv) { | 544 | while(*argv) { |
545 | if(!(host_ptr->entry = malloc(strlen(*argv) + 1))) { | 545 | if(!(host_ptr->entry = malloc(strlen(*argv) + 1))) { |
546 | crash("Failed to allocate memory for hostname"); | 546 | crash(_("Failed to allocate memory for hostname")); |
547 | } | 547 | } |
548 | memset(host_ptr->entry, 0, strlen(*argv) + 1); | 548 | memset(host_ptr->entry, 0, strlen(*argv) + 1); |
549 | host_ptr->entry = memcpy(host_ptr->entry, *argv, strlen(*argv)); | 549 | host_ptr->entry = memcpy(host_ptr->entry, *argv, strlen(*argv)); |
550 | if(!(host_ptr->next = malloc(sizeof(struct host_name_list)))) | 550 | if(!(host_ptr->next = malloc(sizeof(struct host_name_list)))) |
551 | crash("Failed to allocate memory for hostname"); | 551 | crash(_("Failed to allocate memory for hostname")); |
552 | host_ptr = host_ptr->next; | 552 | host_ptr = host_ptr->next; |
553 | host_ptr->next = NULL; | 553 | host_ptr->next = NULL; |
554 | 554 | ||
@@ -565,13 +565,13 @@ int main(int argc, char **argv) | |||
565 | } | 565 | } |
566 | 566 | ||
567 | if(!num_hosts) { | 567 | if(!num_hosts) { |
568 | printf("No hosts to work with!\n\n"); | 568 | printf(_("No hosts to work with!\n\n")); |
569 | print_usage(); | 569 | print_usage(); |
570 | } | 570 | } |
571 | 571 | ||
572 | /* allocate array to hold outstanding ping requests */ | 572 | /* allocate array to hold outstanding ping requests */ |
573 | table = (HOST_ENTRY **) malloc(sizeof(HOST_ENTRY *) * num_hosts); | 573 | table = (HOST_ENTRY **) malloc(sizeof(HOST_ENTRY *) * num_hosts); |
574 | if(!table) crash("Can't malloc array of hosts"); | 574 | if(!table) crash(_("Can't malloc array of hosts")); |
575 | 575 | ||
576 | cursor = rrlist; | 576 | cursor = rrlist; |
577 | 577 | ||
@@ -703,7 +703,7 @@ void finish() | |||
703 | warn.pl, crit.pl); | 703 | warn.pl, crit.pl); |
704 | } | 704 | } |
705 | else { | 705 | else { |
706 | printf("%s is down (lost 100%%)", h->host); | 706 | printf(_("%s is down (lost 100%%)"), h->host); |
707 | } | 707 | } |
708 | } | 708 | } |
709 | else { | 709 | else { |
@@ -754,7 +754,7 @@ void finish() | |||
754 | } | 754 | } |
755 | 755 | ||
756 | if(num_noaddress) { | 756 | if(num_noaddress) { |
757 | printf("No hostaddress specified.\n"); | 757 | printf(_("No hostaddress specified.\n")); |
758 | print_usage(); | 758 | print_usage(); |
759 | } | 759 | } |
760 | else if(num_alive != num_hosts) { | 760 | else if(num_alive != num_hosts) { |
@@ -765,10 +765,10 @@ void finish() | |||
765 | 765 | ||
766 | if(num_hosts > 1) { | 766 | if(num_hosts > 1) { |
767 | if(num_alive == num_hosts) { | 767 | if(num_alive == num_hosts) { |
768 | printf("OK - All %d hosts are alive\n", num_hosts); | 768 | printf(_("OK - All %d hosts are alive\n"), num_hosts); |
769 | } | 769 | } |
770 | else { | 770 | else { |
771 | printf("CRITICAL - %d of %d hosts are alive\n", num_alive, num_hosts); | 771 | printf(_("CRITICAL - %d of %d hosts are alive\n"), num_alive, num_hosts); |
772 | } | 772 | } |
773 | } | 773 | } |
774 | exit(fin_stat); | 774 | exit(fin_stat); |
@@ -784,7 +784,7 @@ void send_ping(int lsock, HOST_ENTRY *h) | |||
784 | 784 | ||
785 | buffer = (char *)malloc((size_t) ping_pkt_size); | 785 | buffer = (char *)malloc((size_t) ping_pkt_size); |
786 | if(!buffer) | 786 | if(!buffer) |
787 | crash("can't malloc ping packet"); | 787 | crash(_("Can't malloc ping packet")); |
788 | 788 | ||
789 | memset(buffer, 0, ping_pkt_size * sizeof(char)); | 789 | memset(buffer, 0, ping_pkt_size * sizeof(char)); |
790 | icp = (struct icmp *)buffer; | 790 | icp = (struct icmp *)buffer; |
@@ -808,7 +808,7 @@ void send_ping(int lsock, HOST_ENTRY *h) | |||
808 | 808 | ||
809 | if(n < 0 || (unsigned int)n != ping_pkt_size) { | 809 | if(n < 0 || (unsigned int)n != ping_pkt_size) { |
810 | if(unreachable_flag) { | 810 | if(unreachable_flag) { |
811 | printf("%s error while sending ping: %s\n", | 811 | printf(_("%s error while sending ping: %s\n"), |
812 | h->host, strerror(errno)); | 812 | h->host, strerror(errno)); |
813 | } /* IF */ | 813 | } /* IF */ |
814 | 814 | ||
@@ -860,7 +860,7 @@ int wait_for_reply(int lsock) | |||
860 | #endif /* defined(__alpha__) && __STDC__ */ | 860 | #endif /* defined(__alpha__) && __STDC__ */ |
861 | 861 | ||
862 | if(result < hlen + ICMP_MINLEN) { | 862 | if(result < hlen + ICMP_MINLEN) { |
863 | printf("received packet too short for ICMP (%d bytes from %s)\n", result, | 863 | printf(_("Received packet too short for ICMP (%d bytes from %s)\n"), result, |
864 | inet_ntoa(response_addr.sin_addr)); | 864 | inet_ntoa(response_addr.sin_addr)); |
865 | 865 | ||
866 | return (1); /* too short */ | 866 | return (1); /* too short */ |
@@ -903,7 +903,7 @@ int wait_for_reply(int lsock) | |||
903 | /* note reply time in array, probably */ | 903 | /* note reply time in array, probably */ |
904 | if((this_count >= 0) && ((unsigned int)this_count < trials)) { | 904 | if((this_count >= 0) && ((unsigned int)this_count < trials)) { |
905 | if(h->resp_times[this_count] != RESP_WAITING) { | 905 | if(h->resp_times[this_count] != RESP_WAITING) { |
906 | printf("%s : duplicate for [%d], %d bytes, %s ms", | 906 | printf(_("%s : duplicate for [%d], %d bytes, %s ms"), |
907 | h->host, this_count, result, sprint_tm(this_reply)); | 907 | h->host, this_count, result, sprint_tm(this_reply)); |
908 | 908 | ||
909 | if(response_addr.sin_addr.s_addr != h->saddr.sin_addr.s_addr) | 909 | if(response_addr.sin_addr.s_addr != h->saddr.sin_addr.s_addr) |
@@ -913,7 +913,7 @@ int wait_for_reply(int lsock) | |||
913 | } /* IF */ | 913 | } /* IF */ |
914 | else { | 914 | else { |
915 | /* count is out of bounds?? */ | 915 | /* count is out of bounds?? */ |
916 | printf("%s : duplicate for [%d], %d bytes, %s ms\n", | 916 | printf(_("%s : duplicate for [%d], %d bytes, %s ms\n"), |
917 | h->host, this_count, result, sprint_tm(this_reply)); | 917 | h->host, this_count, result, sprint_tm(this_reply)); |
918 | } /* ELSE */ | 918 | } /* ELSE */ |
919 | 919 | ||
@@ -942,12 +942,12 @@ int handle_random_icmp(struct icmp *p, struct sockaddr_in *addr) | |||
942 | h = table[sent_icmp->icmp_seq]; | 942 | h = table[sent_icmp->icmp_seq]; |
943 | 943 | ||
944 | if(p->icmp_code > ICMP_UNREACH_MAXTYPE) { | 944 | if(p->icmp_code > ICMP_UNREACH_MAXTYPE) { |
945 | printf("ICMP Unreachable (Invalid Code) from %s for ICMP Echo sent to %s", | 945 | printf(_("ICMP Unreachable (Invalid Code) from %s for ICMP Echo sent to %s"), |
946 | inet_ntoa(addr->sin_addr), h->host); | 946 | inet_ntoa(addr->sin_addr), h->host); |
947 | 947 | ||
948 | } /* IF */ | 948 | } /* IF */ |
949 | else { | 949 | else { |
950 | printf("ICMP Unreachable from %s for ICMP Echo sent to %s", | 950 | printf(_("ICMP Unreachable from %s for ICMP Echo sent to %s"), |
951 | inet_ntoa(addr->sin_addr), h->host); | 951 | inet_ntoa(addr->sin_addr), h->host); |
952 | 952 | ||
953 | } /* ELSE */ | 953 | } /* ELSE */ |
@@ -971,7 +971,7 @@ int handle_random_icmp(struct icmp *p, struct sockaddr_in *addr) | |||
971 | (sent_icmp->icmp_seq < (n_short) num_hosts)) { | 971 | (sent_icmp->icmp_seq < (n_short) num_hosts)) { |
972 | /* this is a response to a ping we sent */ | 972 | /* this is a response to a ping we sent */ |
973 | h = table[sent_icmp->icmp_seq]; | 973 | h = table[sent_icmp->icmp_seq]; |
974 | printf("ICMP Unreachable from %s for ICMP Echo sent to %s", | 974 | printf(_("ICMP Unreachable from %s for ICMP Echo sent to %s"), |
975 | inet_ntoa(addr->sin_addr), h->host); | 975 | inet_ntoa(addr->sin_addr), h->host); |
976 | 976 | ||
977 | if(inet_addr(h->host) == INADDR_NONE) | 977 | if(inet_addr(h->host) == INADDR_NONE) |
@@ -1056,7 +1056,7 @@ void add_name(char *name) | |||
1056 | } /* IF */ | 1056 | } /* IF */ |
1057 | 1057 | ||
1058 | if(host_ent == NULL) { | 1058 | if(host_ent == NULL) { |
1059 | printf("%s address not found\n", name); | 1059 | printf(_("%s address not found\n"), name); |
1060 | num_noaddress++; | 1060 | num_noaddress++; |
1061 | return; | 1061 | return; |
1062 | } /* IF */ | 1062 | } /* IF */ |
@@ -1064,7 +1064,7 @@ void add_name(char *name) | |||
1064 | 1064 | ||
1065 | host_add = (struct in_addr *)*(host_ent->h_addr_list); | 1065 | host_add = (struct in_addr *)*(host_ent->h_addr_list); |
1066 | if(host_add == NULL) { | 1066 | if(host_add == NULL) { |
1067 | printf("%s has no address data\n", name); | 1067 | printf(_("%s has no address data\n"), name); |
1068 | num_noaddress++; | 1068 | num_noaddress++; |
1069 | return; | 1069 | return; |
1070 | } /* IF */ | 1070 | } /* IF */ |
@@ -1097,7 +1097,7 @@ char *na_cat(char *name, struct in_addr ipaddr) | |||
1097 | nm = (char *)malloc(strlen(name) + strlen(as) + 4); | 1097 | nm = (char *)malloc(strlen(name) + strlen(as) + 4); |
1098 | 1098 | ||
1099 | if(!nm) | 1099 | if(!nm) |
1100 | crash("can't allocate some space for a string"); | 1100 | crash(_("Can't allocate some space for a string")); |
1101 | 1101 | ||
1102 | strcpy(nm, name); | 1102 | strcpy(nm, name); |
1103 | strcat(nm, " ("); | 1103 | strcat(nm, " ("); |
@@ -1116,7 +1116,7 @@ void add_addr(char *name, char *host, struct in_addr ipaddr) | |||
1116 | int *i; | 1116 | int *i; |
1117 | 1117 | ||
1118 | if(!(p = (HOST_ENTRY *) malloc(sizeof(HOST_ENTRY)))) { | 1118 | if(!(p = (HOST_ENTRY *) malloc(sizeof(HOST_ENTRY)))) { |
1119 | crash("can't allocate HOST_ENTRY"); | 1119 | crash(_("Can't allocate HOST_ENTRY")); |
1120 | } | 1120 | } |
1121 | 1121 | ||
1122 | memset((char *)p, 0, sizeof(HOST_ENTRY)); | 1122 | memset((char *)p, 0, sizeof(HOST_ENTRY)); |
@@ -1129,7 +1129,7 @@ void add_addr(char *name, char *host, struct in_addr ipaddr) | |||
1129 | 1129 | ||
1130 | /* array for response time results */ | 1130 | /* array for response time results */ |
1131 | if(!(i = (int *)malloc(trials * sizeof(int)))) { | 1131 | if(!(i = (int *)malloc(trials * sizeof(int)))) { |
1132 | crash("can't allocate resp_times array"); | 1132 | crash(_("Can't allocate resp_times array")); |
1133 | } | 1133 | } |
1134 | 1134 | ||
1135 | for(n = 1; n < trials; n++) | 1135 | for(n = 1; n < trials; n++) |
@@ -1193,7 +1193,7 @@ char *cpystr(char *string) | |||
1193 | 1193 | ||
1194 | if(string) { | 1194 | if(string) { |
1195 | dst = (char *)malloc(1 + strlen(string)); | 1195 | dst = (char *)malloc(1 + strlen(string)); |
1196 | if(!dst) crash("malloc() failed!"); | 1196 | if(!dst) crash(_("malloc() failed!")); |
1197 | 1197 | ||
1198 | strcpy(dst, string); | 1198 | strcpy(dst, string); |
1199 | return dst; | 1199 | return dst; |
@@ -1210,7 +1210,7 @@ void crash(char *msg) | |||
1210 | if(errno) | 1210 | if(errno) |
1211 | printf("%s: %s : %s\n", prog, msg, strerror(errno)); | 1211 | printf("%s: %s : %s\n", prog, msg, strerror(errno)); |
1212 | if(h_errno) | 1212 | if(h_errno) |
1213 | printf("%s: %s : A network error occurred\n", prog, msg); | 1213 | printf(_("%s: %s : A network error occurred\n"), prog, msg); |
1214 | } | 1214 | } |
1215 | else printf("%s: %s\n", prog, msg); | 1215 | else printf("%s: %s\n", prog, msg); |
1216 | 1216 | ||
@@ -1276,7 +1276,7 @@ void u_sleep(int u_sec) | |||
1276 | FD_ZERO(&readset); | 1276 | FD_ZERO(&readset); |
1277 | nfound = select(0, &readset, &writeset, NULL, &to); | 1277 | nfound = select(0, &readset, &writeset, NULL, &to); |
1278 | if(nfound < 0) | 1278 | if(nfound < 0) |
1279 | crash("select() in u_sleep:"); | 1279 | crash(_("select() in u_sleep:")); |
1280 | 1280 | ||
1281 | return; | 1281 | return; |
1282 | } /* u_sleep() */ | 1282 | } /* u_sleep() */ |
@@ -1306,14 +1306,14 @@ int recvfrom_wto(int lsock, char *buf, int len, struct sockaddr *saddr, int timo | |||
1306 | FD_ZERO(&writeset); | 1306 | FD_ZERO(&writeset); |
1307 | FD_SET(lsock, &readset); | 1307 | FD_SET(lsock, &readset); |
1308 | nfound = select(lsock + 1, &readset, &writeset, NULL, &to); | 1308 | nfound = select(lsock + 1, &readset, &writeset, NULL, &to); |
1309 | if(nfound < 0) crash("select() in recvfrom_wto"); | 1309 | if(nfound < 0) crash(_("select() in recvfrom_wto")); |
1310 | 1310 | ||
1311 | if(nfound == 0) return -1; /* timeout */ | 1311 | if(nfound == 0) return -1; /* timeout */ |
1312 | 1312 | ||
1313 | if(nfound) { | 1313 | if(nfound) { |
1314 | slen = sizeof(struct sockaddr); | 1314 | slen = sizeof(struct sockaddr); |
1315 | n = recvfrom(sock, buf, len, 0, saddr, &slen); | 1315 | n = recvfrom(sock, buf, len, 0, saddr, &slen); |
1316 | if(n < 0) crash("recvfrom"); | 1316 | if(n < 0) crash(_("recvfrom")); |
1317 | return(n); | 1317 | return(n); |
1318 | } | 1318 | } |
1319 | 1319 | ||
diff --git a/plugins/check_ide_smart.c b/plugins/check_ide_smart.c index 644dc488..16cd1a87 100644 --- a/plugins/check_ide_smart.c +++ b/plugins/check_ide_smart.c | |||
@@ -206,9 +206,7 @@ main (int argc, char *argv[]) | |||
206 | print_revision (progname, revision); | 206 | print_revision (progname, revision); |
207 | return STATE_OK; | 207 | return STATE_OK; |
208 | default: | 208 | default: |
209 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 209 | usage2 (_("Unknown argument"), optarg); |
210 | print_usage (); | ||
211 | exit (STATE_UNKNOWN); | ||
212 | } | 210 | } |
213 | 211 | ||
214 | if (optind < argc) { | 212 | if (optind < argc) { |
@@ -488,7 +486,6 @@ smart_read_thresholds (int fd, thresholds_t * thresholds) | |||
488 | } | 486 | } |
489 | 487 | ||
490 | 488 | ||
491 | |||
492 | void | 489 | void |
493 | print_help () | 490 | print_help () |
494 | { | 491 | { |
@@ -515,7 +512,6 @@ Usage: %s [DEVICE] [OPTION]\n\ | |||
515 | } | 512 | } |
516 | 513 | ||
517 | 514 | ||
518 | |||
519 | void | 515 | void |
520 | print_usage (void) | 516 | print_usage (void) |
521 | { | 517 | { |
diff --git a/plugins/check_ldap.c b/plugins/check_ldap.c index 582c9564..4f143280 100644 --- a/plugins/check_ldap.c +++ b/plugins/check_ldap.c | |||
@@ -134,11 +134,11 @@ main (int argc, char *argv[]) | |||
134 | if (ldap_set_option (ld, LDAP_OPT_X_TLS, &tls) != LDAP_SUCCESS) | 134 | if (ldap_set_option (ld, LDAP_OPT_X_TLS, &tls) != LDAP_SUCCESS) |
135 | { | 135 | { |
136 | /*ldap_perror(ld, "ldaps_option"); */ | 136 | /*ldap_perror(ld, "ldaps_option"); */ |
137 | printf ("Could not init TLS at port %i!\n", ld_port); | 137 | printf (_("Could not init TLS at port %i!\n"), ld_port); |
138 | return STATE_CRITICAL; | 138 | return STATE_CRITICAL; |
139 | } | 139 | } |
140 | #else | 140 | #else |
141 | printf ("TLS not supported by the libraries!\n", ld_port); | 141 | printf (_("TLS not supported by the libraries!\n"), ld_port); |
142 | return STATE_CRITICAL; | 142 | return STATE_CRITICAL; |
143 | #endif /* LDAP_OPT_X_TLS */ | 143 | #endif /* LDAP_OPT_X_TLS */ |
144 | } else { | 144 | } else { |
@@ -157,11 +157,11 @@ main (int argc, char *argv[]) | |||
157 | if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS) | 157 | if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS) |
158 | { | 158 | { |
159 | /*ldap_perror(ld, "ldap_start_tls"); */ | 159 | /*ldap_perror(ld, "ldap_start_tls"); */ |
160 | printf ("Could not init startTLS at port %i!\n", ld_port); | 160 | printf (_("Could not init startTLS at port %i!\n"), ld_port); |
161 | return STATE_CRITICAL; | 161 | return STATE_CRITICAL; |
162 | } | 162 | } |
163 | #else | 163 | #else |
164 | printf ("startTLS not supported by the library, needs LDAPv3!\n"); | 164 | printf (_("startTLS not supported by the library, needs LDAPv3!\n")); |
165 | return STATE_CRITICAL; | 165 | return STATE_CRITICAL; |
166 | #endif /* HAVE_LDAP_START_TLS_S */ | 166 | #endif /* HAVE_LDAP_START_TLS_S */ |
167 | } | 167 | } |
@@ -312,9 +312,7 @@ process_arguments (int argc, char **argv) | |||
312 | #endif | 312 | #endif |
313 | break; | 313 | break; |
314 | default: | 314 | default: |
315 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 315 | usage2 (_("Unknown argument"), optarg); |
316 | print_usage (); | ||
317 | exit (STATE_UNKNOWN); | ||
318 | } | 316 | } |
319 | } | 317 | } |
320 | 318 | ||
@@ -328,21 +326,20 @@ process_arguments (int argc, char **argv) | |||
328 | return validate_arguments (); | 326 | return validate_arguments (); |
329 | } | 327 | } |
330 | 328 | ||
329 | |||
331 | int | 330 | int |
332 | validate_arguments () | 331 | validate_arguments () |
333 | { | 332 | { |
334 | if (ld_host==NULL || strlen(ld_host)==0) | 333 | if (ld_host==NULL || strlen(ld_host)==0) |
335 | usage (_("please specify the host name\n")); | 334 | usage4 (_("Please specify the host name\n")); |
336 | 335 | ||
337 | if (ld_base==NULL || strlen(ld_base)==0) | 336 | if (ld_base==NULL || strlen(ld_base)==0) |
338 | usage (_("please specify the LDAP base\n")); | 337 | usage4 (_("Please specify the LDAP base\n")); |
339 | 338 | ||
340 | return OK; | 339 | return OK; |
341 | |||
342 | } | 340 | } |
343 | 341 | ||
344 | 342 | ||
345 | |||
346 | void | 343 | void |
347 | print_help (void) | 344 | print_help (void) |
348 | { | 345 | { |
@@ -392,7 +389,6 @@ print_help (void) | |||
392 | } | 389 | } |
393 | 390 | ||
394 | 391 | ||
395 | |||
396 | void | 392 | void |
397 | print_usage (void) | 393 | print_usage (void) |
398 | { | 394 | { |
diff --git a/plugins/check_load.c b/plugins/check_load.c index 1b7865c7..7e1cc481 100644 --- a/plugins/check_load.c +++ b/plugins/check_load.c | |||
@@ -224,9 +224,7 @@ process_arguments (int argc, char **argv) | |||
224 | print_help (); | 224 | print_help (); |
225 | exit (STATE_OK); | 225 | exit (STATE_OK); |
226 | case '?': /* help */ | 226 | case '?': /* help */ |
227 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 227 | usage2 (_("Unknown argument"), optarg); |
228 | print_usage (); | ||
229 | exit (STATE_UNKNOWN); | ||
230 | } | 228 | } |
231 | } | 229 | } |
232 | 230 | ||
diff --git a/plugins/check_mrtg.c b/plugins/check_mrtg.c index bd37aeff..067429cf 100644 --- a/plugins/check_mrtg.c +++ b/plugins/check_mrtg.c | |||
@@ -233,9 +233,7 @@ process_arguments (int argc, char **argv) | |||
233 | print_help (); | 233 | print_help (); |
234 | exit (STATE_OK); | 234 | exit (STATE_OK); |
235 | case '?': /* help */ | 235 | case '?': /* help */ |
236 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 236 | usage2 (_("Unknown argument"), optarg); |
237 | print_usage (); | ||
238 | exit (STATE_UNKNOWN); | ||
239 | } | 237 | } |
240 | } | 238 | } |
241 | 239 | ||
diff --git a/plugins/check_mrtgtraf.c b/plugins/check_mrtgtraf.c index 096b3bde..877072ce 100644 --- a/plugins/check_mrtgtraf.c +++ b/plugins/check_mrtgtraf.c | |||
@@ -260,9 +260,7 @@ process_arguments (int argc, char **argv) | |||
260 | print_help (); | 260 | print_help (); |
261 | exit (STATE_OK); | 261 | exit (STATE_OK); |
262 | case '?': /* help */ | 262 | case '?': /* help */ |
263 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 263 | usage2 (_("Unknown argument"), optarg); |
264 | print_usage (); | ||
265 | exit (STATE_UNKNOWN); | ||
266 | } | 264 | } |
267 | } | 265 | } |
268 | 266 | ||
@@ -304,7 +302,6 @@ process_arguments (int argc, char **argv) | |||
304 | } | 302 | } |
305 | 303 | ||
306 | 304 | ||
307 | |||
308 | int | 305 | int |
309 | validate_arguments (void) | 306 | validate_arguments (void) |
310 | { | 307 | { |
@@ -312,7 +309,6 @@ validate_arguments (void) | |||
312 | } | 309 | } |
313 | 310 | ||
314 | 311 | ||
315 | |||
316 | void | 312 | void |
317 | print_help (void) | 313 | print_help (void) |
318 | { | 314 | { |
diff --git a/plugins/check_mysql.c b/plugins/check_mysql.c index 1e7a82f9..735eaa2e 100644 --- a/plugins/check_mysql.c +++ b/plugins/check_mysql.c | |||
@@ -98,25 +98,25 @@ main (int argc, char **argv) | |||
98 | /* check the slave status */ | 98 | /* check the slave status */ |
99 | if (mysql_query (&mysql, "show slave status") != 0) { | 99 | if (mysql_query (&mysql, "show slave status") != 0) { |
100 | mysql_close (&mysql); | 100 | mysql_close (&mysql); |
101 | die (STATE_CRITICAL, "slave query error: %s\n", mysql_error (&mysql)); | 101 | die (STATE_CRITICAL, _("slave query error: %s\n"), mysql_error (&mysql)); |
102 | } | 102 | } |
103 | 103 | ||
104 | /* store the result */ | 104 | /* store the result */ |
105 | if ( (res = mysql_store_result (&mysql)) == NULL) { | 105 | if ( (res = mysql_store_result (&mysql)) == NULL) { |
106 | mysql_close (&mysql); | 106 | mysql_close (&mysql); |
107 | die (STATE_CRITICAL, "slave store_result error: %s\n", mysql_error (&mysql)); | 107 | die (STATE_CRITICAL, _("slave store_result error: %s\n"), mysql_error (&mysql)); |
108 | } | 108 | } |
109 | 109 | ||
110 | /* fetch the first row */ | 110 | /* fetch the first row */ |
111 | if ( (row = mysql_fetch_row (res)) == NULL) { | 111 | if ( (row = mysql_fetch_row (res)) == NULL) { |
112 | mysql_free_result (res); | 112 | mysql_free_result (res); |
113 | mysql_close (&mysql); | 113 | mysql_close (&mysql); |
114 | die (STATE_CRITICAL, "slave fetch row error: %s\n", mysql_error (&mysql)); | 114 | die (STATE_CRITICAL, _("slave fetch row error: %s\n"), mysql_error (&mysql)); |
115 | } | 115 | } |
116 | 116 | ||
117 | if (mysql_field_count (&mysql) == 12) { | 117 | if (mysql_field_count (&mysql) == 12) { |
118 | /* mysql 3.23.x */ | 118 | /* mysql 3.23.x */ |
119 | snprintf (slaveresult, SLAVERESULTSIZE, "Slave running: %s", row[6]); | 119 | snprintf (slaveresult, SLAVERESULTSIZE, _("Slave running: %s"), row[6]); |
120 | if (strcmp (row[6], "Yes") != 0) { | 120 | if (strcmp (row[6], "Yes") != 0) { |
121 | mysql_free_result (res); | 121 | mysql_free_result (res); |
122 | mysql_close (&mysql); | 122 | mysql_close (&mysql); |
@@ -151,7 +151,6 @@ main (int argc, char **argv) | |||
151 | } | 151 | } |
152 | 152 | ||
153 | 153 | ||
154 | |||
155 | /* process command-line arguments */ | 154 | /* process command-line arguments */ |
156 | int | 155 | int |
157 | process_arguments (int argc, char **argv) | 156 | process_arguments (int argc, char **argv) |
@@ -212,9 +211,7 @@ process_arguments (int argc, char **argv) | |||
212 | print_help (); | 211 | print_help (); |
213 | exit (STATE_OK); | 212 | exit (STATE_OK); |
214 | case '?': /* help */ | 213 | case '?': /* help */ |
215 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 214 | usage2 (_("Unknown argument"), optarg); |
216 | print_usage (); | ||
217 | exit (STATE_UNKNOWN); | ||
218 | } | 215 | } |
219 | } | 216 | } |
220 | 217 | ||
@@ -245,7 +242,6 @@ process_arguments (int argc, char **argv) | |||
245 | } | 242 | } |
246 | 243 | ||
247 | 244 | ||
248 | |||
249 | int | 245 | int |
250 | validate_arguments (void) | 246 | validate_arguments (void) |
251 | { | 247 | { |
@@ -265,7 +261,6 @@ validate_arguments (void) | |||
265 | } | 261 | } |
266 | 262 | ||
267 | 263 | ||
268 | |||
269 | void | 264 | void |
270 | print_help (void) | 265 | print_help (void) |
271 | { | 266 | { |
@@ -304,7 +299,6 @@ a server listening on MySQL standard port %d will be checked\n"), MYSQL_PORT); | |||
304 | } | 299 | } |
305 | 300 | ||
306 | 301 | ||
307 | |||
308 | void | 302 | void |
309 | print_usage (void) | 303 | print_usage (void) |
310 | { | 304 | { |
diff --git a/plugins/check_nagios.c b/plugins/check_nagios.c index 465b409d..0176983c 100644 --- a/plugins/check_nagios.c +++ b/plugins/check_nagios.c | |||
@@ -95,7 +95,7 @@ main (int argc, char **argv) | |||
95 | fclose (fp); | 95 | fclose (fp); |
96 | 96 | ||
97 | if (verbose >= 2) | 97 | if (verbose >= 2) |
98 | printf("command: %s\n", PS_COMMAND); | 98 | printf(_("command: %s\n"), PS_COMMAND); |
99 | 99 | ||
100 | /* run the command to check for the Nagios process.. */ | 100 | /* run the command to check for the Nagios process.. */ |
101 | child_process = spopen (PS_COMMAND); | 101 | child_process = spopen (PS_COMMAND); |
@@ -206,8 +206,7 @@ process_arguments (int argc, char **argv) | |||
206 | expire_minutes = atoi (argv[2]); | 206 | expire_minutes = atoi (argv[2]); |
207 | else | 207 | else |
208 | die (STATE_UNKNOWN, | 208 | die (STATE_UNKNOWN, |
209 | _("Expiration time must be an integer (seconds)\nType '%s -h' for additional help\n"), | 209 | _("Expiration time must be an integer (seconds)\n")); |
210 | progname); | ||
211 | process_string = argv[3]; | 210 | process_string = argv[3]; |
212 | return OK; | 211 | return OK; |
213 | } | 212 | } |
@@ -220,9 +219,7 @@ process_arguments (int argc, char **argv) | |||
220 | 219 | ||
221 | switch (c) { | 220 | switch (c) { |
222 | case '?': /* print short usage statement if args not parsable */ | 221 | case '?': /* print short usage statement if args not parsable */ |
223 | printf (_("%s: Unknown argument: %c\n\n"), progname, optopt); | 222 | usage2 (_("Unknown argument"), optarg); |
224 | print_usage (); | ||
225 | exit (STATE_UNKNOWN); | ||
226 | case 'h': /* help */ | 223 | case 'h': /* help */ |
227 | print_help (); | 224 | print_help (); |
228 | exit (STATE_OK); | 225 | exit (STATE_OK); |
@@ -240,8 +237,7 @@ process_arguments (int argc, char **argv) | |||
240 | expire_minutes = atoi (optarg); | 237 | expire_minutes = atoi (optarg); |
241 | else | 238 | else |
242 | die (STATE_UNKNOWN, | 239 | die (STATE_UNKNOWN, |
243 | _("Expiration time must be an integer (seconds)\nType '%s -h' for additional help\n"), | 240 | _("Expiration time must be an integer (seconds)\n")); |
244 | progname); | ||
245 | break; | 241 | break; |
246 | case 'v': | 242 | case 'v': |
247 | verbose++; | 243 | verbose++; |
@@ -252,12 +248,10 @@ process_arguments (int argc, char **argv) | |||
252 | 248 | ||
253 | if (status_log == NULL) | 249 | if (status_log == NULL) |
254 | die (STATE_UNKNOWN, | 250 | die (STATE_UNKNOWN, |
255 | _("You must provide the status_log\nType '%s -h' for additional help\n"), | 251 | _("You must provide the status_log\n")); |
256 | progname); | ||
257 | else if (process_string == NULL) | 252 | else if (process_string == NULL) |
258 | die (STATE_UNKNOWN, | 253 | die (STATE_UNKNOWN, |
259 | _("You must provide a process string\nType '%s -h' for additional help\n"), | 254 | _("You must provide a process string\n")); |
260 | progname); | ||
261 | 255 | ||
262 | return OK; | 256 | return OK; |
263 | } | 257 | } |
diff --git a/plugins/check_nt.c b/plugins/check_nt.c index fa93fce7..cac826f5 100644 --- a/plugins/check_nt.c +++ b/plugins/check_nt.c | |||
@@ -423,7 +423,7 @@ int main(int argc, char **argv){ | |||
423 | 423 | ||
424 | case CHECK_NONE: | 424 | case CHECK_NONE: |
425 | default: | 425 | default: |
426 | usage (_("Please specify a variable to check")); | 426 | usage4 (_("Please specify a variable to check")); |
427 | break; | 427 | break; |
428 | 428 | ||
429 | } | 429 | } |
@@ -487,14 +487,12 @@ int process_arguments(int argc, char **argv){ | |||
487 | switch (c) | 487 | switch (c) |
488 | { | 488 | { |
489 | case '?': /* print short usage statement if args not parsable */ | 489 | case '?': /* print short usage statement if args not parsable */ |
490 | printf("%s: Unknown argument: %s\n\n",progname,optarg); | 490 | usage2 (_("Unknown argument"), optarg); |
491 | print_usage(); | ||
492 | exit(STATE_UNKNOWN); | ||
493 | case 'h': /* help */ | 491 | case 'h': /* help */ |
494 | print_help(); | 492 | print_help(); |
495 | exit(STATE_OK); | 493 | exit(STATE_OK); |
496 | case 'V': /* version */ | 494 | case 'V': /* version */ |
497 | print_revision(progname,"$Revision$"); | 495 | print_revision(progname,revision); |
498 | exit(STATE_OK); | 496 | exit(STATE_OK); |
499 | case 'H': /* hostname */ | 497 | case 'H': /* hostname */ |
500 | if (server_address) free(server_address); | 498 | if (server_address) free(server_address); |
@@ -507,7 +505,7 @@ int process_arguments(int argc, char **argv){ | |||
507 | if (is_intnonneg(optarg)) | 505 | if (is_intnonneg(optarg)) |
508 | server_port=atoi(optarg); | 506 | server_port=atoi(optarg); |
509 | else | 507 | else |
510 | die(STATE_UNKNOWN,_("Server port an integer (seconds)\nType '%s -h' for additional help\n"),progname); | 508 | die(STATE_UNKNOWN,_("Server port must be an integer\n")); |
511 | break; | 509 | break; |
512 | case 'v': | 510 | case 'v': |
513 | if(strlen(optarg)<4) | 511 | if(strlen(optarg)<4) |
@@ -573,7 +571,7 @@ void fetch_data (const char *address, int port, const char *sendb) { | |||
573 | result=process_tcp_request(address, port, sendb, recv_buffer,sizeof(recv_buffer)); | 571 | result=process_tcp_request(address, port, sendb, recv_buffer,sizeof(recv_buffer)); |
574 | 572 | ||
575 | if(result!=STATE_OK) | 573 | if(result!=STATE_OK) |
576 | die (result, "could not fetch information from server\n"); | 574 | die (result, _("could not fetch information from server\n")); |
577 | 575 | ||
578 | if (!strncmp(recv_buffer,"ERROR",5)) | 576 | if (!strncmp(recv_buffer,"ERROR",5)) |
579 | die (STATE_UNKNOWN, "NSClient - %s\n",recv_buffer); | 577 | die (STATE_UNKNOWN, "NSClient - %s\n",recv_buffer); |
diff --git a/plugins/check_nwstat.c b/plugins/check_nwstat.c index 2d7e611d..601b25d3 100644 --- a/plugins/check_nwstat.c +++ b/plugins/check_nwstat.c | |||
@@ -760,9 +760,7 @@ int process_arguments(int argc, char **argv) { | |||
760 | switch (c) | 760 | switch (c) |
761 | { | 761 | { |
762 | case '?': /* print short usage statement if args not parsable */ | 762 | case '?': /* print short usage statement if args not parsable */ |
763 | printf ("%s: Unknown argument: %s\n\n", progname, optarg); | 763 | usage2 (_("Unknown argument"), optarg); |
764 | print_usage(); | ||
765 | exit(STATE_UNKNOWN); | ||
766 | case 'h': /* help */ | 764 | case 'h': /* help */ |
767 | print_help(); | 765 | print_help(); |
768 | exit(STATE_OK); | 766 | exit(STATE_OK); |
@@ -779,7 +777,7 @@ int process_arguments(int argc, char **argv) { | |||
779 | if (is_intnonneg(optarg)) | 777 | if (is_intnonneg(optarg)) |
780 | server_port=atoi(optarg); | 778 | server_port=atoi(optarg); |
781 | else | 779 | else |
782 | die(STATE_UNKNOWN,_("Server port an integer (seconds)\nType '%s -h' for additional help\n"),progname); | 780 | die(STATE_UNKNOWN,_("Server port an integer\n")); |
783 | break; | 781 | break; |
784 | case 'v': | 782 | case 'v': |
785 | if (strlen(optarg)<3) | 783 | if (strlen(optarg)<3) |
diff --git a/plugins/check_overcr.c b/plugins/check_overcr.c index 9bf40d3c..a4abf2b9 100644 --- a/plugins/check_overcr.c +++ b/plugins/check_overcr.c | |||
@@ -272,17 +272,9 @@ main (int argc, char **argv) | |||
272 | die (STATE_UNKNOWN, _("Nothing to check!\n")); | 272 | die (STATE_UNKNOWN, _("Nothing to check!\n")); |
273 | break; | 273 | break; |
274 | } | 274 | } |
275 | |||
276 | /* reset timeout */ | ||
277 | /* alarm (0); */ | ||
278 | |||
279 | /* printf (_("Reached end of program with no data returned\n")); */ | ||
280 | |||
281 | /* return result; */ | ||
282 | } | 275 | } |
283 | 276 | ||
284 | 277 | ||
285 | |||
286 | /* process command-line arguments */ | 278 | /* process command-line arguments */ |
287 | int | 279 | int |
288 | process_arguments (int argc, char **argv) | 280 | process_arguments (int argc, char **argv) |
@@ -332,9 +324,7 @@ process_arguments (int argc, char **argv) | |||
332 | 324 | ||
333 | switch (c) { | 325 | switch (c) { |
334 | case '?': /* print short usage statement if args not parsable */ | 326 | case '?': /* print short usage statement if args not parsable */ |
335 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 327 | usage2 (_("Unknown argument"), optarg); |
336 | print_usage (); | ||
337 | exit (STATE_UNKNOWN); | ||
338 | case 'h': /* help */ | 328 | case 'h': /* help */ |
339 | print_help (); | 329 | print_help (); |
340 | exit (STATE_OK); | 330 | exit (STATE_OK); |
@@ -349,8 +339,7 @@ process_arguments (int argc, char **argv) | |||
349 | server_port = atoi (optarg); | 339 | server_port = atoi (optarg); |
350 | else | 340 | else |
351 | die (STATE_UNKNOWN, | 341 | die (STATE_UNKNOWN, |
352 | _("Server port an integer (seconds)\nType '%s -h' for additional help\n"), | 342 | _("Server port an integer\n")); |
353 | progname); | ||
354 | break; | 343 | break; |
355 | case 'v': /* variable */ | 344 | case 'v': /* variable */ |
356 | if (strcmp (optarg, "LOAD") == 0) { | 345 | if (strcmp (optarg, "LOAD") == 0) { |
@@ -403,7 +392,6 @@ process_arguments (int argc, char **argv) | |||
403 | } | 392 | } |
404 | 393 | ||
405 | 394 | ||
406 | |||
407 | void | 395 | void |
408 | print_help (void) | 396 | print_help (void) |
409 | { | 397 | { |
@@ -459,7 +447,6 @@ Notes:\n\ | |||
459 | } | 447 | } |
460 | 448 | ||
461 | 449 | ||
462 | |||
463 | void | 450 | void |
464 | print_usage (void) | 451 | print_usage (void) |
465 | { | 452 | { |
diff --git a/plugins/check_pgsql.c b/plugins/check_pgsql.c index b5b9ff81..d56ce9b0 100644 --- a/plugins/check_pgsql.c +++ b/plugins/check_pgsql.c | |||
@@ -209,9 +209,7 @@ process_arguments (int argc, char **argv) | |||
209 | 209 | ||
210 | switch (c) { | 210 | switch (c) { |
211 | case '?': /* usage */ | 211 | case '?': /* usage */ |
212 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 212 | usage2 (_("Unknown argument"), optarg); |
213 | print_usage (); | ||
214 | exit (STATE_UNKNOWN); | ||
215 | case 'h': /* help */ | 213 | case 'h': /* help */ |
216 | print_help (); | 214 | print_help (); |
217 | exit (STATE_OK); | 215 | exit (STATE_OK); |
@@ -232,7 +230,7 @@ process_arguments (int argc, char **argv) | |||
232 | break; | 230 | break; |
233 | case 'w': /* warning time threshold */ | 231 | case 'w': /* warning time threshold */ |
234 | if (!is_nonnegative (optarg)) | 232 | if (!is_nonnegative (optarg)) |
235 | usage2 (_("Critical threshold must be a positive integer"), optarg); | 233 | usage2 (_("Warning threshold must be a positive integer"), optarg); |
236 | else | 234 | else |
237 | twarn = strtod (optarg, NULL); | 235 | twarn = strtod (optarg, NULL); |
238 | break; | 236 | break; |
diff --git a/plugins/check_ping.c b/plugins/check_ping.c index 91764666..818bb668 100644 --- a/plugins/check_ping.c +++ b/plugins/check_ping.c | |||
@@ -194,9 +194,7 @@ process_arguments (int argc, char **argv) | |||
194 | 194 | ||
195 | switch (c) { | 195 | switch (c) { |
196 | case '?': /* usage */ | 196 | case '?': /* usage */ |
197 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 197 | usage2 (_("Unknown argument"), optarg); |
198 | print_usage (); | ||
199 | exit (STATE_UNKNOWN); | ||
200 | case 'h': /* help */ | 198 | case 'h': /* help */ |
201 | print_help (); | 199 | print_help (); |
202 | exit (STATE_OK); | 200 | exit (STATE_OK); |
diff --git a/plugins/check_procs.c b/plugins/check_procs.c index 1be93f46..0cd9153c 100644 --- a/plugins/check_procs.c +++ b/plugins/check_procs.c | |||
@@ -343,9 +343,7 @@ process_arguments (int argc, char **argv) | |||
343 | 343 | ||
344 | switch (c) { | 344 | switch (c) { |
345 | case '?': /* help */ | 345 | case '?': /* help */ |
346 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 346 | usage2 (_("Unknown argument"), optarg); |
347 | print_usage (); | ||
348 | exit (STATE_UNKNOWN); | ||
349 | case 'h': /* help */ | 347 | case 'h': /* help */ |
350 | print_help (); | 348 | print_help (); |
351 | exit (STATE_OK); | 349 | exit (STATE_OK); |
@@ -368,7 +366,7 @@ process_arguments (int argc, char **argv) | |||
368 | else if (sscanf (optarg, "%d:", &cmin) == 1) | 366 | else if (sscanf (optarg, "%d:", &cmin) == 1) |
369 | break; | 367 | break; |
370 | else | 368 | else |
371 | usage (_("Critical Process Count must be an integer!\n\n")); | 369 | usage4 (_("Critical Process Count must be an integer!")); |
372 | break; | 370 | break; |
373 | case 'w': /* warning threshold */ | 371 | case 'w': /* warning threshold */ |
374 | if (is_integer (optarg)) | 372 | if (is_integer (optarg)) |
@@ -380,7 +378,7 @@ process_arguments (int argc, char **argv) | |||
380 | else if (sscanf (optarg, "%d:", &wmin) == 1) | 378 | else if (sscanf (optarg, "%d:", &wmin) == 1) |
381 | break; | 379 | break; |
382 | else | 380 | else |
383 | usage (_("Warning Process Count must be an integer!\n\n")); | 381 | usage4 (_("Warning Process Count must be an integer!")); |
384 | break; | 382 | break; |
385 | case 'p': /* process id */ | 383 | case 'p': /* process id */ |
386 | if (sscanf (optarg, "%d%[^0-9]", &ppid, tmp) == 1) { | 384 | if (sscanf (optarg, "%d%[^0-9]", &ppid, tmp) == 1) { |
@@ -388,7 +386,7 @@ process_arguments (int argc, char **argv) | |||
388 | options |= PPID; | 386 | options |= PPID; |
389 | break; | 387 | break; |
390 | } | 388 | } |
391 | usage2 (_("%s: Parent Process ID must be an integer!\n\n"), progname); | 389 | usage4 (_("Parent Process ID must be an integer!")); |
392 | case 's': /* status */ | 390 | case 's': /* status */ |
393 | if (statopts) | 391 | if (statopts) |
394 | break; | 392 | break; |
@@ -403,13 +401,13 @@ process_arguments (int argc, char **argv) | |||
403 | pw = getpwuid ((uid_t) uid); | 401 | pw = getpwuid ((uid_t) uid); |
404 | /* check to be sure user exists */ | 402 | /* check to be sure user exists */ |
405 | if (pw == NULL) | 403 | if (pw == NULL) |
406 | usage2 (_("UID %s was not found\n"), optarg); | 404 | usage2 (_("UID %s was not found"), optarg); |
407 | } | 405 | } |
408 | else { | 406 | else { |
409 | pw = getpwnam (optarg); | 407 | pw = getpwnam (optarg); |
410 | /* check to be sure user exists */ | 408 | /* check to be sure user exists */ |
411 | if (pw == NULL) | 409 | if (pw == NULL) |
412 | usage2 (_("User name %s was not found\n"), optarg); | 410 | usage2 (_("User name %s was not found"), optarg); |
413 | /* then get uid */ | 411 | /* then get uid */ |
414 | uid = pw->pw_uid; | 412 | uid = pw->pw_uid; |
415 | } | 413 | } |
@@ -443,14 +441,14 @@ process_arguments (int argc, char **argv) | |||
443 | options |= RSS; | 441 | options |= RSS; |
444 | break; | 442 | break; |
445 | } | 443 | } |
446 | usage2 (_("%s: RSS must be an integer!\n\n"), progname); | 444 | usage4 (_("RSS must be an integer!")); |
447 | case 'z': /* VSZ */ | 445 | case 'z': /* VSZ */ |
448 | if (sscanf (optarg, "%d%[^0-9]", &vsz, tmp) == 1) { | 446 | if (sscanf (optarg, "%d%[^0-9]", &vsz, tmp) == 1) { |
449 | asprintf (&fmt, _("%s%sVSZ >= %d"), (fmt ? fmt : ""), (options ? ", " : ""), vsz); | 447 | asprintf (&fmt, _("%s%sVSZ >= %d"), (fmt ? fmt : ""), (options ? ", " : ""), vsz); |
450 | options |= VSZ; | 448 | options |= VSZ; |
451 | break; | 449 | break; |
452 | } | 450 | } |
453 | usage2 (_("%s: VSZ must be an integer!\n\n"), progname); | 451 | usage4 (_("VSZ must be an integer!")); |
454 | case 'P': /* PCPU */ | 452 | case 'P': /* PCPU */ |
455 | /* TODO: -P 1.5.5 is accepted */ | 453 | /* TODO: -P 1.5.5 is accepted */ |
456 | if (sscanf (optarg, "%f%[^0-9.]", &pcpu, tmp) == 1) { | 454 | if (sscanf (optarg, "%f%[^0-9.]", &pcpu, tmp) == 1) { |
@@ -458,7 +456,7 @@ process_arguments (int argc, char **argv) | |||
458 | options |= PCPU; | 456 | options |= PCPU; |
459 | break; | 457 | break; |
460 | } | 458 | } |
461 | usage2 (_("%s: PCPU must be a float!\n\n"), progname); | 459 | usage4 (_("PCPU must be a float!")); |
462 | case 'm': | 460 | case 'm': |
463 | asprintf (&metric_name, "%s", optarg); | 461 | asprintf (&metric_name, "%s", optarg); |
464 | if ( strcmp(optarg, "PROCS") == 0) { | 462 | if ( strcmp(optarg, "PROCS") == 0) { |
@@ -482,10 +480,7 @@ process_arguments (int argc, char **argv) | |||
482 | break; | 480 | break; |
483 | } | 481 | } |
484 | 482 | ||
485 | printf (_("%s: metric must be one of PROCS, VSZ, RSS, CPU, ELAPSED!\n\n"), | 483 | usage4 (_("Metric must be one of PROCS, VSZ, RSS, CPU, ELAPSED!")); |
486 | progname); | ||
487 | print_usage (); | ||
488 | exit (STATE_UNKNOWN); | ||
489 | case 'v': /* command */ | 484 | case 'v': /* command */ |
490 | verbose++; | 485 | verbose++; |
491 | break; | 486 | break; |
@@ -588,8 +583,6 @@ check_thresholds (int value) | |||
588 | } | 583 | } |
589 | 584 | ||
590 | 585 | ||
591 | |||
592 | |||
593 | /* convert the elapsed time to seconds */ | 586 | /* convert the elapsed time to seconds */ |
594 | int | 587 | int |
595 | convert_to_seconds(char *etime) { | 588 | convert_to_seconds(char *etime) { |
@@ -653,7 +646,6 @@ convert_to_seconds(char *etime) { | |||
653 | } | 646 | } |
654 | 647 | ||
655 | 648 | ||
656 | |||
657 | void | 649 | void |
658 | print_help (void) | 650 | print_help (void) |
659 | { | 651 | { |
diff --git a/plugins/check_radius.c b/plugins/check_radius.c index 9e104686..07ee4c7f 100644 --- a/plugins/check_radius.c +++ b/plugins/check_radius.c | |||
@@ -199,12 +199,12 @@ process_arguments (int argc, char **argv) | |||
199 | if (is_intpos (argv[5])) | 199 | if (is_intpos (argv[5])) |
200 | retries = atoi (argv[5]); | 200 | retries = atoi (argv[5]); |
201 | else | 201 | else |
202 | usage (_("Number of retries must be a positive integer")); | 202 | usage4 (_("Number of retries must be a positive integer")); |
203 | server = argv[6]; | 203 | server = argv[6]; |
204 | if (is_intpos (argv[7])) | 204 | if (is_intpos (argv[7])) |
205 | port = atoi (argv[7]); | 205 | port = atoi (argv[7]); |
206 | else | 206 | else |
207 | usage (_("Port must be a positive integer")); | 207 | usage4 (_("Port must be a positive integer")); |
208 | expect = argv[8]; | 208 | expect = argv[8]; |
209 | return OK; | 209 | return OK; |
210 | } | 210 | } |
@@ -218,9 +218,7 @@ process_arguments (int argc, char **argv) | |||
218 | 218 | ||
219 | switch (c) { | 219 | switch (c) { |
220 | case '?': /* print short usage statement if args not parsable */ | 220 | case '?': /* print short usage statement if args not parsable */ |
221 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 221 | usage2 (_("Unknown argument"), optarg); |
222 | print_usage (); | ||
223 | exit (STATE_UNKNOWN); | ||
224 | case 'h': /* help */ | 222 | case 'h': /* help */ |
225 | print_help (); | 223 | print_help (); |
226 | exit (OK); | 224 | exit (OK); |
@@ -240,7 +238,7 @@ process_arguments (int argc, char **argv) | |||
240 | if (is_intnonneg (optarg)) | 238 | if (is_intnonneg (optarg)) |
241 | port = atoi (optarg); | 239 | port = atoi (optarg); |
242 | else | 240 | else |
243 | usage (_("Port must be a positive integer")); | 241 | usage4 (_("Port must be a positive integer")); |
244 | break; | 242 | break; |
245 | case 'u': /* username */ | 243 | case 'u': /* username */ |
246 | username = optarg; | 244 | username = optarg; |
@@ -261,7 +259,7 @@ process_arguments (int argc, char **argv) | |||
261 | if (is_intpos (optarg)) | 259 | if (is_intpos (optarg)) |
262 | retries = atoi (optarg); | 260 | retries = atoi (optarg); |
263 | else | 261 | else |
264 | usage (_("Number of retries must be a positive integer")); | 262 | usage4 (_("Number of retries must be a positive integer")); |
265 | break; | 263 | break; |
266 | case 't': /* timeout */ | 264 | case 't': /* timeout */ |
267 | if (is_intpos (optarg)) | 265 | if (is_intpos (optarg)) |
diff --git a/plugins/check_real.c b/plugins/check_real.c index 30424656..eb892c77 100644 --- a/plugins/check_real.c +++ b/plugins/check_real.c | |||
@@ -330,7 +330,7 @@ process_arguments (int argc, char **argv) | |||
330 | check_critical_time = TRUE; | 330 | check_critical_time = TRUE; |
331 | } | 331 | } |
332 | else { | 332 | else { |
333 | usage4 (_("Critical time must be a nonnegative integer")); | 333 | usage4 (_("Critical time must be a positive integer")); |
334 | } | 334 | } |
335 | break; | 335 | break; |
336 | case 'v': /* verbose */ | 336 | case 'v': /* verbose */ |
@@ -341,7 +341,7 @@ process_arguments (int argc, char **argv) | |||
341 | socket_timeout = atoi (optarg); | 341 | socket_timeout = atoi (optarg); |
342 | } | 342 | } |
343 | else { | 343 | else { |
344 | usage4 (_("Time interval must be a nonnegative integer")); | 344 | usage4 (_("Timeout interval must be a positive integer")); |
345 | } | 345 | } |
346 | break; | 346 | break; |
347 | case 'V': /* version */ | 347 | case 'V': /* version */ |
@@ -351,9 +351,7 @@ process_arguments (int argc, char **argv) | |||
351 | print_help (); | 351 | print_help (); |
352 | exit (STATE_OK); | 352 | exit (STATE_OK); |
353 | case '?': /* usage */ | 353 | case '?': /* usage */ |
354 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 354 | usage2 (_("Unknown argument"), optarg); |
355 | print_usage (); | ||
356 | exit (STATE_UNKNOWN); | ||
357 | } | 355 | } |
358 | } | 356 | } |
359 | 357 | ||
@@ -368,7 +366,7 @@ process_arguments (int argc, char **argv) | |||
368 | } | 366 | } |
369 | 367 | ||
370 | if (server_address==NULL) | 368 | if (server_address==NULL) |
371 | usage (_("You must provide a server to check\n")); | 369 | usage4 (_("You must provide a server to check")); |
372 | 370 | ||
373 | if (host_name==NULL) | 371 | if (host_name==NULL) |
374 | host_name = strdup (server_address); | 372 | host_name = strdup (server_address); |
diff --git a/plugins/check_smtp.c b/plugins/check_smtp.c index b6c60c24..55cf5da5 100644 --- a/plugins/check_smtp.c +++ b/plugins/check_smtp.c | |||
@@ -351,7 +351,7 @@ process_arguments (int argc, char **argv) | |||
351 | socket_timeout = atoi (optarg); | 351 | socket_timeout = atoi (optarg); |
352 | } | 352 | } |
353 | else { | 353 | else { |
354 | usage4 (_("Time interval must be a positive integer")); | 354 | usage4 (_("Timeout interval must be a positive integer")); |
355 | } | 355 | } |
356 | break; | 356 | break; |
357 | case '4': | 357 | case '4': |
@@ -371,9 +371,7 @@ process_arguments (int argc, char **argv) | |||
371 | print_help (); | 371 | print_help (); |
372 | exit (STATE_OK); | 372 | exit (STATE_OK); |
373 | case '?': /* help */ | 373 | case '?': /* help */ |
374 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 374 | usage2 (_("Unknown argument"), optarg); |
375 | print_usage (); | ||
376 | exit (STATE_UNKNOWN); | ||
377 | } | 375 | } |
378 | } | 376 | } |
379 | 377 | ||
diff --git a/plugins/check_snmp.c b/plugins/check_snmp.c index c1c4ea83..5f221218 100644 --- a/plugins/check_snmp.c +++ b/plugins/check_snmp.c | |||
@@ -251,7 +251,7 @@ main (int argc, char **argv) | |||
251 | eval_method[i] & WARN_NE) { | 251 | eval_method[i] & WARN_NE) { |
252 | p2 = strpbrk (p2, "0123456789"); | 252 | p2 = strpbrk (p2, "0123456789"); |
253 | if (p2 == NULL) | 253 | if (p2 == NULL) |
254 | die (STATE_UNKNOWN,"No valid data returned"); | 254 | die (STATE_UNKNOWN,_("No valid data returned")); |
255 | response_value[i] = strtoul (p2, NULL, 10); | 255 | response_value[i] = strtoul (p2, NULL, 10); |
256 | iresult = check_num (i); | 256 | iresult = check_num (i); |
257 | asprintf (&show, "%lu", response_value[i]); | 257 | asprintf (&show, "%lu", response_value[i]); |
@@ -398,9 +398,7 @@ process_arguments (int argc, char **argv) | |||
398 | 398 | ||
399 | switch (c) { | 399 | switch (c) { |
400 | case '?': /* usage */ | 400 | case '?': /* usage */ |
401 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 401 | usage2 (_("Unknown argument"), optarg); |
402 | print_usage (); | ||
403 | exit (STATE_UNKNOWN); | ||
404 | case 'h': /* help */ | 402 | case 'h': /* help */ |
405 | print_help (); | 403 | print_help (); |
406 | exit (STATE_OK); | 404 | exit (STATE_OK); |
@@ -795,7 +793,7 @@ thisarg (char *str) | |||
795 | str += strspn (str, " \t\r\n"); /* trim any leading whitespace */ | 793 | str += strspn (str, " \t\r\n"); /* trim any leading whitespace */ |
796 | if (strstr (str, "'") == str) { /* handle SIMPLE quoted strings */ | 794 | if (strstr (str, "'") == str) { /* handle SIMPLE quoted strings */ |
797 | if (strlen (str) == 1 || !strstr (str + 1, "'")) | 795 | if (strlen (str) == 1 || !strstr (str + 1, "'")) |
798 | die (STATE_UNKNOWN, "Unbalanced quotes\n"); | 796 | die (STATE_UNKNOWN, _("Unbalanced quotes\n")); |
799 | } | 797 | } |
800 | return str; | 798 | return str; |
801 | } | 799 | } |
diff --git a/plugins/check_ssh.c b/plugins/check_ssh.c index e957c053..7b7bc8fd 100644 --- a/plugins/check_ssh.c +++ b/plugins/check_ssh.c | |||
@@ -110,9 +110,7 @@ process_arguments (int argc, char **argv) | |||
110 | 110 | ||
111 | switch (c) { | 111 | switch (c) { |
112 | case '?': /* help */ | 112 | case '?': /* help */ |
113 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 113 | usage2 (_("Unknown argument"), optarg); |
114 | print_usage (); | ||
115 | exit (STATE_UNKNOWN); | ||
116 | case 'V': /* version */ | 114 | case 'V': /* version */ |
117 | print_revision (progname, revision); | 115 | print_revision (progname, revision); |
118 | exit (STATE_OK); | 116 | exit (STATE_OK); |
@@ -135,7 +133,7 @@ process_arguments (int argc, char **argv) | |||
135 | #ifdef USE_IPV6 | 133 | #ifdef USE_IPV6 |
136 | address_family = AF_INET6; | 134 | address_family = AF_INET6; |
137 | #else | 135 | #else |
138 | usage (_("IPv6 support not available\n")); | 136 | usage4 (_("IPv6 support not available")); |
139 | #endif | 137 | #endif |
140 | break; | 138 | break; |
141 | case 'r': /* remote version */ | 139 | case 'r': /* remote version */ |
@@ -151,11 +149,9 @@ process_arguments (int argc, char **argv) | |||
151 | port = atoi (optarg); | 149 | port = atoi (optarg); |
152 | } | 150 | } |
153 | else { | 151 | else { |
154 | printf ("Port number nust be a positive integer: %s\n", optarg); | 152 | usage2 (_("Port number must be a positive integer"), optarg); |
155 | usage (""); | ||
156 | } | 153 | } |
157 | } | 154 | } |
158 | |||
159 | } | 155 | } |
160 | 156 | ||
161 | c = optind; | 157 | c = optind; |
diff --git a/plugins/check_swap.c b/plugins/check_swap.c index 6e2ab723..093845b4 100644 --- a/plugins/check_swap.c +++ b/plugins/check_swap.c | |||
@@ -239,7 +239,7 @@ main (int argc, char **argv) | |||
239 | /* and now, tally 'em up */ | 239 | /* and now, tally 'em up */ |
240 | swapctl_res=swapctl(SC_LIST, tbl); | 240 | swapctl_res=swapctl(SC_LIST, tbl); |
241 | if(swapctl_res < 0){ | 241 | if(swapctl_res < 0){ |
242 | perror("swapctl failed: "); | 242 | perror(_("swapctl failed: ")); |
243 | result = STATE_WARNING; | 243 | result = STATE_WARNING; |
244 | } | 244 | } |
245 | 245 | ||
@@ -278,7 +278,7 @@ main (int argc, char **argv) | |||
278 | /* and now, tally 'em up */ | 278 | /* and now, tally 'em up */ |
279 | swapctl_res=swapctl(SWAP_STATS, ent, nswaps); | 279 | swapctl_res=swapctl(SWAP_STATS, ent, nswaps); |
280 | if(swapctl_res < 0){ | 280 | if(swapctl_res < 0){ |
281 | perror("swapctl failed: "); | 281 | perror(_("swapctl failed: ")); |
282 | result = STATE_WARNING; | 282 | result = STATE_WARNING; |
283 | } | 283 | } |
284 | 284 | ||
@@ -388,7 +388,7 @@ process_arguments (int argc, char **argv) | |||
388 | break; | 388 | break; |
389 | } | 389 | } |
390 | else { | 390 | else { |
391 | usage (_("Warning threshold must be integer or percentage!\n")); | 391 | usage4 (_("Warning threshold must be integer or percentage!")); |
392 | } | 392 | } |
393 | case 'c': /* critical size threshold */ | 393 | case 'c': /* critical size threshold */ |
394 | if (is_intnonneg (optarg)) { | 394 | if (is_intnonneg (optarg)) { |
@@ -420,9 +420,7 @@ process_arguments (int argc, char **argv) | |||
420 | print_help (); | 420 | print_help (); |
421 | exit (STATE_OK); | 421 | exit (STATE_OK); |
422 | case '?': /* error */ | 422 | case '?': /* error */ |
423 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 423 | usage2 (_("Unknown argument"), optarg); |
424 | print_usage (); | ||
425 | exit (STATE_UNKNOWN); | ||
426 | } | 424 | } |
427 | } | 425 | } |
428 | 426 | ||
diff --git a/plugins/check_tcp.c b/plugins/check_tcp.c index b922536e..fcd67786 100644 --- a/plugins/check_tcp.c +++ b/plugins/check_tcp.c | |||
@@ -259,13 +259,13 @@ main (int argc, char **argv) | |||
259 | #ifdef HAVE_SSL | 259 | #ifdef HAVE_SSL |
260 | if (use_ssl && check_cert == TRUE) { | 260 | if (use_ssl && check_cert == TRUE) { |
261 | if (connect_SSL () != OK) | 261 | if (connect_SSL () != OK) |
262 | die (STATE_CRITICAL,"CRITICAL - Could not make SSL connection\n"); | 262 | die (STATE_CRITICAL,_("CRITICAL - Could not make SSL connection\n")); |
263 | if ((server_cert = SSL_get_peer_certificate (ssl)) != NULL) { | 263 | if ((server_cert = SSL_get_peer_certificate (ssl)) != NULL) { |
264 | result = check_certificate (&server_cert); | 264 | result = check_certificate (&server_cert); |
265 | X509_free(server_cert); | 265 | X509_free(server_cert); |
266 | } | 266 | } |
267 | else { | 267 | else { |
268 | printf("CRITICAL - Cannot retrieve server certificate.\n"); | 268 | printf(_("CRITICAL - Cannot retrieve server certificate.\n")); |
269 | result = STATE_CRITICAL; | 269 | result = STATE_CRITICAL; |
270 | } | 270 | } |
271 | SSL_shutdown (ssl); | 271 | SSL_shutdown (ssl); |
@@ -434,7 +434,7 @@ process_arguments (int argc, char **argv) | |||
434 | }; | 434 | }; |
435 | 435 | ||
436 | if (argc < 2) | 436 | if (argc < 2) |
437 | usage ("No arguments found\n"); | 437 | usage4 (_("No arguments found")); |
438 | 438 | ||
439 | /* backwards compatibility */ | 439 | /* backwards compatibility */ |
440 | for (c = 1; c < argc; c++) { | 440 | for (c = 1; c < argc; c++) { |
@@ -462,14 +462,12 @@ process_arguments (int argc, char **argv) | |||
462 | 462 | ||
463 | switch (c) { | 463 | switch (c) { |
464 | case '?': /* print short usage statement if args not parsable */ | 464 | case '?': /* print short usage statement if args not parsable */ |
465 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 465 | usage2 (_("Unknown argument"), optarg); |
466 | print_usage (); | ||
467 | exit (STATE_UNKNOWN); | ||
468 | case 'h': /* help */ | 466 | case 'h': /* help */ |
469 | print_help (); | 467 | print_help (); |
470 | exit (STATE_OK); | 468 | exit (STATE_OK); |
471 | case 'V': /* version */ | 469 | case 'V': /* version */ |
472 | print_revision (progname, "$Revision$"); | 470 | print_revision (progname, revision); |
473 | exit (STATE_OK); | 471 | exit (STATE_OK); |
474 | case 'v': /* verbose mode */ | 472 | case 'v': /* verbose mode */ |
475 | verbose = TRUE; | 473 | verbose = TRUE; |
@@ -575,7 +573,7 @@ process_arguments (int argc, char **argv) | |||
575 | case 'D': /* Check SSL cert validity - days 'til certificate expiration */ | 573 | case 'D': /* Check SSL cert validity - days 'til certificate expiration */ |
576 | #ifdef HAVE_SSL | 574 | #ifdef HAVE_SSL |
577 | if (!is_intnonneg (optarg)) | 575 | if (!is_intnonneg (optarg)) |
578 | usage2 ("invalid certificate expiration period", optarg); | 576 | usage2 (_("Invalid certificate expiration period"), optarg); |
579 | days_till_exp = atoi (optarg); | 577 | days_till_exp = atoi (optarg); |
580 | check_cert = TRUE; | 578 | check_cert = TRUE; |
581 | use_ssl = TRUE; | 579 | use_ssl = TRUE; |
@@ -583,14 +581,14 @@ process_arguments (int argc, char **argv) | |||
583 | case 'S': | 581 | case 'S': |
584 | use_ssl = TRUE; | 582 | use_ssl = TRUE; |
585 | #else | 583 | #else |
586 | die (STATE_UNKNOWN, "SSL support not available. Install OpenSSL and recompile."); | 584 | die (STATE_UNKNOWN, _("SSL support not available. Install OpenSSL and recompile.")); |
587 | #endif | 585 | #endif |
588 | break; | 586 | break; |
589 | } | 587 | } |
590 | } | 588 | } |
591 | 589 | ||
592 | if (server_address == NULL) | 590 | if (server_address == NULL) |
593 | usage (_("You must provide a server address\n")); | 591 | usage4 (_("You must provide a server address")); |
594 | 592 | ||
595 | return TRUE; | 593 | return TRUE; |
596 | } | 594 | } |
@@ -669,7 +667,7 @@ check_certificate (X509 ** certificate) | |||
669 | /* Generate tm structure to process timestamp */ | 667 | /* Generate tm structure to process timestamp */ |
670 | if (tm->type == V_ASN1_UTCTIME) { | 668 | if (tm->type == V_ASN1_UTCTIME) { |
671 | if (tm->length < 10) { | 669 | if (tm->length < 10) { |
672 | printf ("CRITICAL - Wrong time format in certificate.\n"); | 670 | printf (_("CRITICAL - Wrong time format in certificate.\n")); |
673 | return STATE_CRITICAL; | 671 | return STATE_CRITICAL; |
674 | } | 672 | } |
675 | else { | 673 | else { |
@@ -681,7 +679,7 @@ check_certificate (X509 ** certificate) | |||
681 | } | 679 | } |
682 | else { | 680 | else { |
683 | if (tm->length < 12) { | 681 | if (tm->length < 12) { |
684 | printf ("CRITICAL - Wrong time format in certificate.\n"); | 682 | printf (_("CRITICAL - Wrong time format in certificate.\n")); |
685 | return STATE_CRITICAL; | 683 | return STATE_CRITICAL; |
686 | } | 684 | } |
687 | else { | 685 | else { |
@@ -710,20 +708,20 @@ check_certificate (X509 ** certificate) | |||
710 | stamp.tm_mday, stamp.tm_year + 1900, stamp.tm_hour, stamp.tm_min); | 708 | stamp.tm_mday, stamp.tm_year + 1900, stamp.tm_hour, stamp.tm_min); |
711 | 709 | ||
712 | if (days_left > 0 && days_left <= days_till_exp) { | 710 | if (days_left > 0 && days_left <= days_till_exp) { |
713 | printf ("Certificate expires in %d day(s) (%s).\n", days_left, timestamp); | 711 | printf (_("Certificate expires in %d day(s) (%s).\n"), days_left, timestamp); |
714 | return STATE_WARNING; | 712 | return STATE_WARNING; |
715 | } | 713 | } |
716 | if (days_left < 0) { | 714 | if (days_left < 0) { |
717 | printf ("Certificate expired on %s.\n", timestamp); | 715 | printf (_("Certificate expired on %s.\n"), timestamp); |
718 | return STATE_CRITICAL; | 716 | return STATE_CRITICAL; |
719 | } | 717 | } |
720 | 718 | ||
721 | if (days_left == 0) { | 719 | if (days_left == 0) { |
722 | printf ("Certificate expires today (%s).\n", timestamp); | 720 | printf (_("Certificate expires today (%s).\n"), timestamp); |
723 | return STATE_WARNING; | 721 | return STATE_WARNING; |
724 | } | 722 | } |
725 | 723 | ||
726 | printf ("Certificate will expire on %s.\n", timestamp); | 724 | printf (_("Certificate will expire on %s.\n"), timestamp); |
727 | 725 | ||
728 | return STATE_OK; | 726 | return STATE_OK; |
729 | } | 727 | } |
diff --git a/plugins/check_time.c b/plugins/check_time.c index 63d7ee25..efca91bd 100644 --- a/plugins/check_time.c +++ b/plugins/check_time.c | |||
@@ -216,9 +216,7 @@ process_arguments (int argc, char **argv) | |||
216 | 216 | ||
217 | switch (c) { | 217 | switch (c) { |
218 | case '?': /* print short usage statement if args not parsable */ | 218 | case '?': /* print short usage statement if args not parsable */ |
219 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 219 | usage2 (_("Unknown argument"), optarg); |
220 | print_usage (); | ||
221 | exit (STATE_UNKNOWN); | ||
222 | case 'h': /* help */ | 220 | case 'h': /* help */ |
223 | print_help (); | 221 | print_help (); |
224 | exit (STATE_OK); | 222 | exit (STATE_OK); |
diff --git a/plugins/check_udp.c b/plugins/check_udp.c index b79f31f7..e7d5280c 100644 --- a/plugins/check_udp.c +++ b/plugins/check_udp.c | |||
@@ -67,7 +67,7 @@ main (int argc, char **argv) | |||
67 | time (&end_time); | 67 | time (&end_time); |
68 | 68 | ||
69 | if (result != STATE_OK) { | 69 | if (result != STATE_OK) { |
70 | printf ("No response from host on port %d\n", server_port); | 70 | printf (_("No response from host on port %d\n"), server_port); |
71 | result = STATE_CRITICAL; | 71 | result = STATE_CRITICAL; |
72 | } | 72 | } |
73 | 73 | ||
@@ -76,7 +76,7 @@ main (int argc, char **argv) | |||
76 | /* check to see if we got the response we wanted */ | 76 | /* check to see if we got the response we wanted */ |
77 | if (server_expect) { | 77 | if (server_expect) { |
78 | if (!strstr (recv_buffer, server_expect)) { | 78 | if (!strstr (recv_buffer, server_expect)) { |
79 | printf ("Invalid response received from host on port %d\n", | 79 | printf (_("Invalid response received from host on port %d\n"), |
80 | server_port); | 80 | server_port); |
81 | result = STATE_CRITICAL; | 81 | result = STATE_CRITICAL; |
82 | } | 82 | } |
@@ -146,9 +146,7 @@ process_arguments (int argc, char **argv) | |||
146 | 146 | ||
147 | switch (c) { | 147 | switch (c) { |
148 | case '?': /* print short usage statement if args not parsable */ | 148 | case '?': /* print short usage statement if args not parsable */ |
149 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 149 | usage2 (_("Unknown argument"), optarg); |
150 | print_usage (); | ||
151 | exit (STATE_UNKNOWN); | ||
152 | case 'h': /* help */ | 150 | case 'h': /* help */ |
153 | print_help (); | 151 | print_help (); |
154 | exit (STATE_OK); | 152 | exit (STATE_OK); |
@@ -254,8 +252,6 @@ STATE_CRITICAL, other errors return STATE_UNKNOWN.\n\n")); | |||
254 | } | 252 | } |
255 | 253 | ||
256 | 254 | ||
257 | |||
258 | |||
259 | /* Original Command line: | 255 | /* Original Command line: |
260 | check_udp <host_address> [-p port] [-s send] [-e expect] \ | 256 | check_udp <host_address> [-p port] [-s send] [-e expect] \ |
261 | [-wt warn_time] [-ct crit_time] [-to to_sec] */ | 257 | [-wt warn_time] [-ct crit_time] [-to to_sec] */ |
diff --git a/plugins/check_ups.c b/plugins/check_ups.c index a4d76503..1cdf9e9e 100644 --- a/plugins/check_ups.c +++ b/plugins/check_ups.c | |||
@@ -133,48 +133,48 @@ main (int argc, char **argv) | |||
133 | } | 133 | } |
134 | else if ((status & (UPSSTATUS_OB | UPSSTATUS_LB)) == | 134 | else if ((status & (UPSSTATUS_OB | UPSSTATUS_LB)) == |
135 | (UPSSTATUS_OB | UPSSTATUS_LB)) { | 135 | (UPSSTATUS_OB | UPSSTATUS_LB)) { |
136 | asprintf (&ups_status, "On Battery, Low Battery"); | 136 | asprintf (&ups_status, _("On Battery, Low Battery")); |
137 | result = STATE_CRITICAL; | 137 | result = STATE_CRITICAL; |
138 | } | 138 | } |
139 | else { | 139 | else { |
140 | if (status & UPSSTATUS_OL) { | 140 | if (status & UPSSTATUS_OL) { |
141 | asprintf (&ups_status, "%s%s", ups_status, "Online"); | 141 | asprintf (&ups_status, "%s%s", ups_status, _("Online")); |
142 | } | 142 | } |
143 | if (status & UPSSTATUS_OB) { | 143 | if (status & UPSSTATUS_OB) { |
144 | asprintf (&ups_status, "%s%s", ups_status, "On Battery"); | 144 | asprintf (&ups_status, "%s%s", ups_status, _("On Battery")); |
145 | result = STATE_WARNING; | 145 | result = STATE_WARNING; |
146 | } | 146 | } |
147 | if (status & UPSSTATUS_LB) { | 147 | if (status & UPSSTATUS_LB) { |
148 | asprintf (&ups_status, "%s%s", ups_status, ", Low Battery"); | 148 | asprintf (&ups_status, "%s%s", ups_status, _(", Low Battery")); |
149 | result = STATE_WARNING; | 149 | result = STATE_WARNING; |
150 | } | 150 | } |
151 | if (status & UPSSTATUS_CAL) { | 151 | if (status & UPSSTATUS_CAL) { |
152 | asprintf (&ups_status, "%s%s", ups_status, ", Calibrating"); | 152 | asprintf (&ups_status, "%s%s", ups_status, _(", Calibrating")); |
153 | } | 153 | } |
154 | if (status & UPSSTATUS_RB) { | 154 | if (status & UPSSTATUS_RB) { |
155 | asprintf (&ups_status, "%s%s", ups_status, ", Replace Battery"); | 155 | asprintf (&ups_status, "%s%s", ups_status, _(", Replace Battery")); |
156 | result = STATE_WARNING; | 156 | result = STATE_WARNING; |
157 | } | 157 | } |
158 | if (status & UPSSTATUS_BYPASS) { | 158 | if (status & UPSSTATUS_BYPASS) { |
159 | asprintf (&ups_status, "%s%s", ups_status, ", On Bypass"); | 159 | asprintf (&ups_status, "%s%s", ups_status, _(", On Bypass")); |
160 | } | 160 | } |
161 | if (status & UPSSTATUS_OVER) { | 161 | if (status & UPSSTATUS_OVER) { |
162 | asprintf (&ups_status, "%s%s", ups_status, ", Overload"); | 162 | asprintf (&ups_status, "%s%s", ups_status, _(", Overload")); |
163 | } | 163 | } |
164 | if (status & UPSSTATUS_TRIM) { | 164 | if (status & UPSSTATUS_TRIM) { |
165 | asprintf (&ups_status, "%s%s", ups_status, ", Trimming"); | 165 | asprintf (&ups_status, "%s%s", ups_status, _(", Trimming")); |
166 | } | 166 | } |
167 | if (status & UPSSTATUS_BOOST) { | 167 | if (status & UPSSTATUS_BOOST) { |
168 | asprintf (&ups_status, "%s%s", ups_status, ", Boosting"); | 168 | asprintf (&ups_status, "%s%s", ups_status, _(", Boosting")); |
169 | } | 169 | } |
170 | if (status & UPSSTATUS_CHRG) { | 170 | if (status & UPSSTATUS_CHRG) { |
171 | asprintf (&ups_status, "%s%s", ups_status, ", Charging"); | 171 | asprintf (&ups_status, "%s%s", ups_status, _(", Charging")); |
172 | } | 172 | } |
173 | if (status & UPSSTATUS_DISCHRG) { | 173 | if (status & UPSSTATUS_DISCHRG) { |
174 | asprintf (&ups_status, "%s%s", ups_status, ", Discharging"); | 174 | asprintf (&ups_status, "%s%s", ups_status, _(", Discharging")); |
175 | } | 175 | } |
176 | if (status & UPSSTATUS_UNKOWN) { | 176 | if (status & UPSSTATUS_UNKOWN) { |
177 | asprintf (&ups_status, "%s%s", ups_status, ", Unknown"); | 177 | asprintf (&ups_status, "%s%s", ups_status, _(", Unknown")); |
178 | } | 178 | } |
179 | } | 179 | } |
180 | asprintf (&message, "%sStatus=%s ", message, ups_status); | 180 | asprintf (&message, "%sStatus=%s ", message, ups_status); |
@@ -311,7 +311,7 @@ main (int argc, char **argv) | |||
311 | /* if the UPS does not support any options we are looking for, report an error */ | 311 | /* if the UPS does not support any options we are looking for, report an error */ |
312 | if (supported_options == UPS_NONE) { | 312 | if (supported_options == UPS_NONE) { |
313 | result = STATE_CRITICAL; | 313 | result = STATE_CRITICAL; |
314 | asprintf (&message, "UPS does not support any available options\n"); | 314 | asprintf (&message, _("UPS does not support any available options\n")); |
315 | } | 315 | } |
316 | 316 | ||
317 | /* reset timeout */ | 317 | /* reset timeout */ |
@@ -335,7 +335,7 @@ determine_status (void) | |||
335 | res=get_ups_variable ("ups.status", recv_buffer, sizeof (recv_buffer)); | 335 | res=get_ups_variable ("ups.status", recv_buffer, sizeof (recv_buffer)); |
336 | if (res == NOSUCHVAR) return OK; | 336 | if (res == NOSUCHVAR) return OK; |
337 | if (res != STATE_OK) { | 337 | if (res != STATE_OK) { |
338 | printf ("Invalid response received from host\n"); | 338 | printf (_("Invalid response received from host\n")); |
339 | return ERROR; | 339 | return ERROR; |
340 | } | 340 | } |
341 | 341 | ||
@@ -395,7 +395,7 @@ get_ups_variable (const char *varname, char *buf, size_t buflen) | |||
395 | if (process_tcp_request | 395 | if (process_tcp_request |
396 | (server_address, server_port, send_buffer, temp_buffer, | 396 | (server_address, server_port, send_buffer, temp_buffer, |
397 | sizeof (temp_buffer)) != STATE_OK) { | 397 | sizeof (temp_buffer)) != STATE_OK) { |
398 | printf ("Invalid response received from host\n"); | 398 | printf (_("Invalid response received from host\n")); |
399 | return ERROR; | 399 | return ERROR; |
400 | } | 400 | } |
401 | 401 | ||
@@ -403,7 +403,7 @@ get_ups_variable (const char *varname, char *buf, size_t buflen) | |||
403 | len = strlen(ptr); | 403 | len = strlen(ptr); |
404 | if (len > 0 && ptr[len-1] == '\n') ptr[len-1]=0; | 404 | if (len > 0 && ptr[len-1] == '\n') ptr[len-1]=0; |
405 | if (strcmp (ptr, "ERR UNKNOWN-UPS") == 0) { | 405 | if (strcmp (ptr, "ERR UNKNOWN-UPS") == 0) { |
406 | printf ("CRITICAL - no such ups '%s' on that host\n", ups_name); | 406 | printf (_("CRITICAL - no such ups '%s' on that host\n"), ups_name); |
407 | return ERROR; | 407 | return ERROR; |
408 | } | 408 | } |
409 | 409 | ||
@@ -413,19 +413,19 @@ get_ups_variable (const char *varname, char *buf, size_t buflen) | |||
413 | } | 413 | } |
414 | 414 | ||
415 | if (strcmp (ptr, "ERR DATA-STALE") == 0) { | 415 | if (strcmp (ptr, "ERR DATA-STALE") == 0) { |
416 | printf ("CRITICAL - UPS data is stale\n"); | 416 | printf (_("CRITICAL - UPS data is stale\n")); |
417 | return ERROR; | 417 | return ERROR; |
418 | } | 418 | } |
419 | 419 | ||
420 | if (strncmp (ptr, "ERR", 3) == 0) { | 420 | if (strncmp (ptr, "ERR", 3) == 0) { |
421 | printf ("Unknown error: %s\n", ptr); | 421 | printf (_("Unknown error: %s\n"), ptr); |
422 | return ERROR; | 422 | return ERROR; |
423 | } | 423 | } |
424 | 424 | ||
425 | ptr = temp_buffer + strlen (varname) + strlen (ups_name) + 6; | 425 | ptr = temp_buffer + strlen (varname) + strlen (ups_name) + 6; |
426 | len = strlen(ptr); | 426 | len = strlen(ptr); |
427 | if (len < 2 || ptr[0] != '"' || ptr[len-1] != '"') { | 427 | if (len < 2 || ptr[0] != '"' || ptr[len-1] != '"') { |
428 | printf ("Error: unable to parse variable\n"); | 428 | printf (_("Error: unable to parse variable\n")); |
429 | return ERROR; | 429 | return ERROR; |
430 | } | 430 | } |
431 | strncpy (buf, ptr+1, len - 2); | 431 | strncpy (buf, ptr+1, len - 2); |
@@ -481,9 +481,7 @@ process_arguments (int argc, char **argv) | |||
481 | 481 | ||
482 | switch (c) { | 482 | switch (c) { |
483 | case '?': /* help */ | 483 | case '?': /* help */ |
484 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 484 | usage2 (_("Unknown argument"), optarg); |
485 | print_usage (); | ||
486 | exit (STATE_UNKNOWN); | ||
487 | case 'H': /* hostname */ | 485 | case 'H': /* hostname */ |
488 | if (is_host (optarg)) { | 486 | if (is_host (optarg)) { |
489 | server_address = optarg; | 487 | server_address = optarg; |
@@ -503,7 +501,7 @@ process_arguments (int argc, char **argv) | |||
503 | server_port = atoi (optarg); | 501 | server_port = atoi (optarg); |
504 | } | 502 | } |
505 | else { | 503 | else { |
506 | usage2 ("Port must be a positive integer", optarg); | 504 | usage2 (_("Port must be a positive integer"), optarg); |
507 | } | 505 | } |
508 | break; | 506 | break; |
509 | case 'c': /* critical time threshold */ | 507 | case 'c': /* critical time threshold */ |
@@ -512,7 +510,7 @@ process_arguments (int argc, char **argv) | |||
512 | check_crit = TRUE; | 510 | check_crit = TRUE; |
513 | } | 511 | } |
514 | else { | 512 | else { |
515 | usage2 ("Critical time must be a positive integer", optarg); | 513 | usage2 (_("Critical time must be a positive integer"), optarg); |
516 | } | 514 | } |
517 | break; | 515 | break; |
518 | case 'w': /* warning time threshold */ | 516 | case 'w': /* warning time threshold */ |
@@ -521,7 +519,7 @@ process_arguments (int argc, char **argv) | |||
521 | check_warn = TRUE; | 519 | check_warn = TRUE; |
522 | } | 520 | } |
523 | else { | 521 | else { |
524 | usage2 ("Warning time must be a positive integer", optarg); | 522 | usage2 (_("Warning time must be a positive integer"), optarg); |
525 | } | 523 | } |
526 | break; | 524 | break; |
527 | case 'v': /* variable */ | 525 | case 'v': /* variable */ |
@@ -534,14 +532,14 @@ process_arguments (int argc, char **argv) | |||
534 | else if (!strcmp (optarg, "LOADPCT")) | 532 | else if (!strcmp (optarg, "LOADPCT")) |
535 | check_variable = UPS_LOADPCT; | 533 | check_variable = UPS_LOADPCT; |
536 | else | 534 | else |
537 | usage2 ("Unrecognized UPS variable", optarg); | 535 | usage2 (_("Unrecognized UPS variable"), optarg); |
538 | break; | 536 | break; |
539 | case 't': /* timeout */ | 537 | case 't': /* timeout */ |
540 | if (is_intnonneg (optarg)) { | 538 | if (is_intnonneg (optarg)) { |
541 | socket_timeout = atoi (optarg); | 539 | socket_timeout = atoi (optarg); |
542 | } | 540 | } |
543 | else { | 541 | else { |
544 | usage ("Time interval must be a positive integer\n"); | 542 | usage4 (_("Timeout interval must be a positive integer")); |
545 | } | 543 | } |
546 | break; | 544 | break; |
547 | case 'V': /* version */ | 545 | case 'V': /* version */ |
@@ -568,19 +566,17 @@ process_arguments (int argc, char **argv) | |||
568 | } | 566 | } |
569 | 567 | ||
570 | 568 | ||
571 | |||
572 | int | 569 | int |
573 | validate_arguments (void) | 570 | validate_arguments (void) |
574 | { | 571 | { |
575 | if (! ups_name) { | 572 | if (! ups_name) { |
576 | printf ("Error : no ups indicated\n"); | 573 | printf (_("Error : no ups indicated\n")); |
577 | return ERROR; | 574 | return ERROR; |
578 | } | 575 | } |
579 | return OK; | 576 | return OK; |
580 | } | 577 | } |
581 | 578 | ||
582 | 579 | ||
583 | |||
584 | void | 580 | void |
585 | print_help (void) | 581 | print_help (void) |
586 | { | 582 | { |
@@ -641,7 +637,6 @@ http://www.networkupstools.org\n\n")); | |||
641 | } | 637 | } |
642 | 638 | ||
643 | 639 | ||
644 | |||
645 | void | 640 | void |
646 | print_usage (void) | 641 | print_usage (void) |
647 | { | 642 | { |
diff --git a/plugins/check_users.c b/plugins/check_users.c index d1b4f018..25d04ed0 100644 --- a/plugins/check_users.c +++ b/plugins/check_users.c | |||
@@ -140,9 +140,7 @@ process_arguments (int argc, char **argv) | |||
140 | 140 | ||
141 | switch (c) { | 141 | switch (c) { |
142 | case '?': /* print short usage statement if args not parsable */ | 142 | case '?': /* print short usage statement if args not parsable */ |
143 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 143 | usage2 (_("Unknown argument"), optarg); |
144 | print_usage (); | ||
145 | exit (STATE_UNKNOWN); | ||
146 | case 'h': /* help */ | 144 | case 'h': /* help */ |
147 | print_help (); | 145 | print_help (); |
148 | exit (STATE_OK); | 146 | exit (STATE_OK); |
@@ -151,13 +149,13 @@ process_arguments (int argc, char **argv) | |||
151 | exit (STATE_OK); | 149 | exit (STATE_OK); |
152 | case 'c': /* critical */ | 150 | case 'c': /* critical */ |
153 | if (!is_intnonneg (optarg)) | 151 | if (!is_intnonneg (optarg)) |
154 | usage (_("Critical threshold must be a positive integer\n")); | 152 | usage4 (_("Critical threshold must be a positive integer")); |
155 | else | 153 | else |
156 | cusers = atoi (optarg); | 154 | cusers = atoi (optarg); |
157 | break; | 155 | break; |
158 | case 'w': /* warning */ | 156 | case 'w': /* warning */ |
159 | if (!is_intnonneg (optarg)) | 157 | if (!is_intnonneg (optarg)) |
160 | usage (_("Warning threshold must be a positive integer\n")); | 158 | usage4 (_("Warning threshold must be a positive integer")); |
161 | else | 159 | else |
162 | wusers = atoi (optarg); | 160 | wusers = atoi (optarg); |
163 | break; | 161 | break; |
@@ -167,14 +165,14 @@ process_arguments (int argc, char **argv) | |||
167 | c = optind; | 165 | c = optind; |
168 | if (wusers == -1 && argc > c) { | 166 | if (wusers == -1 && argc > c) { |
169 | if (is_intnonneg (argv[c]) == FALSE) | 167 | if (is_intnonneg (argv[c]) == FALSE) |
170 | usage (_("Warning threshold must be a positive integer\n")); | 168 | usage4 (_("Warning threshold must be a positive integer")); |
171 | else | 169 | else |
172 | wusers = atoi (argv[c++]); | 170 | wusers = atoi (argv[c++]); |
173 | } | 171 | } |
174 | 172 | ||
175 | if (cusers == -1 && argc > c) { | 173 | if (cusers == -1 && argc > c) { |
176 | if (is_intnonneg (argv[c]) == FALSE) | 174 | if (is_intnonneg (argv[c]) == FALSE) |
177 | usage (_("Warning threshold must be a positive integer\n")); | 175 | usage4 (_("Warning threshold must be a positive integer")); |
178 | else | 176 | else |
179 | cusers = atoi (argv[c]); | 177 | cusers = atoi (argv[c]); |
180 | } | 178 | } |
@@ -210,7 +208,6 @@ system and generates an error if the number exceeds the thresholds specified.\n" | |||
210 | } | 208 | } |
211 | 209 | ||
212 | 210 | ||
213 | |||
214 | void | 211 | void |
215 | print_usage (void) | 212 | print_usage (void) |
216 | { | 213 | { |
diff --git a/plugins/negate.c b/plugins/negate.c index e35ddb9e..d08c3a30 100644 --- a/plugins/negate.c +++ b/plugins/negate.c | |||
@@ -174,9 +174,7 @@ process_arguments (int argc, char **argv) | |||
174 | 174 | ||
175 | switch (c) { | 175 | switch (c) { |
176 | case '?': /* help */ | 176 | case '?': /* help */ |
177 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 177 | usage2 (_("Unknown argument"), optarg); |
178 | print_usage (); | ||
179 | exit (STATE_UNKNOWN); | ||
180 | break; | 178 | break; |
181 | case 'h': /* help */ | 179 | case 'h': /* help */ |
182 | print_help (); | 180 | print_help (); |
diff --git a/plugins/netutils.c b/plugins/netutils.c index 6702b13f..1231c1ef 100644 --- a/plugins/netutils.c +++ b/plugins/netutils.c | |||
@@ -45,9 +45,9 @@ void | |||
45 | socket_timeout_alarm_handler (int sig) | 45 | socket_timeout_alarm_handler (int sig) |
46 | { | 46 | { |
47 | if (sig == SIGALRM) | 47 | if (sig == SIGALRM) |
48 | printf ("CRITICAL - Socket timeout after %d seconds\n", socket_timeout); | 48 | printf (_("CRITICAL - Socket timeout after %d seconds\n"), socket_timeout); |
49 | else | 49 | else |
50 | printf ("CRITICAL - Abnormal timeout after %d seconds\n", socket_timeout); | 50 | printf (_("CRITICAL - Abnormal timeout after %d seconds\n"), socket_timeout); |
51 | 51 | ||
52 | exit (STATE_CRITICAL); | 52 | exit (STATE_CRITICAL); |
53 | } | 53 | } |
@@ -106,7 +106,7 @@ process_tcp_request2 (const char *server_address, int server_port, | |||
106 | 106 | ||
107 | send_result = send (sd, send_buffer, strlen (send_buffer), 0); | 107 | send_result = send (sd, send_buffer, strlen (send_buffer), 0); |
108 | if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) { | 108 | if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) { |
109 | printf ("Send failed\n"); | 109 | printf (_("Send failed\n")); |
110 | result = STATE_WARNING; | 110 | result = STATE_WARNING; |
111 | } | 111 | } |
112 | 112 | ||
@@ -123,7 +123,7 @@ process_tcp_request2 (const char *server_address, int server_port, | |||
123 | if (!FD_ISSET (sd, &readfds)) { /* it hasn't */ | 123 | if (!FD_ISSET (sd, &readfds)) { /* it hasn't */ |
124 | if (!recv_length) { | 124 | if (!recv_length) { |
125 | strcpy (recv_buffer, ""); | 125 | strcpy (recv_buffer, ""); |
126 | printf ("No data was received from host!\n"); | 126 | printf (_("No data was received from host!\n")); |
127 | result = STATE_WARNING; | 127 | result = STATE_WARNING; |
128 | } | 128 | } |
129 | else { /* this one failed, but previous ones worked */ | 129 | else { /* this one failed, but previous ones worked */ |
@@ -239,7 +239,7 @@ my_connect (const char *host_name, int port, int *sd, int proto) | |||
239 | SOCK_DGRAM : SOCK_STREAM, res->ai_protocol); | 239 | SOCK_DGRAM : SOCK_STREAM, res->ai_protocol); |
240 | 240 | ||
241 | if (*sd < 0) { | 241 | if (*sd < 0) { |
242 | printf ("Socket creation failed\n"); | 242 | printf (_("Socket creation failed\n")); |
243 | freeaddrinfo (res); | 243 | freeaddrinfo (res); |
244 | return STATE_UNKNOWN; | 244 | return STATE_UNKNOWN; |
245 | } | 245 | } |
@@ -315,7 +315,7 @@ send_request (int sd, int proto, const char *send_buffer, char *recv_buffer, int | |||
315 | 315 | ||
316 | send_result = send (sd, send_buffer, strlen (send_buffer), 0); | 316 | send_result = send (sd, send_buffer, strlen (send_buffer), 0); |
317 | if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) { | 317 | if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) { |
318 | printf ("Send failed\n"); | 318 | printf (_("Send failed\n")); |
319 | result = STATE_WARNING; | 319 | result = STATE_WARNING; |
320 | } | 320 | } |
321 | 321 | ||
@@ -330,7 +330,7 @@ send_request (int sd, int proto, const char *send_buffer, char *recv_buffer, int | |||
330 | /* make sure some data has arrived */ | 330 | /* make sure some data has arrived */ |
331 | if (!FD_ISSET (sd, &readfds)) { | 331 | if (!FD_ISSET (sd, &readfds)) { |
332 | strcpy (recv_buffer, ""); | 332 | strcpy (recv_buffer, ""); |
333 | printf ("No data was received from host!\n"); | 333 | printf (_("No data was received from host!\n")); |
334 | result = STATE_WARNING; | 334 | result = STATE_WARNING; |
335 | } | 335 | } |
336 | 336 | ||
@@ -339,7 +339,7 @@ send_request (int sd, int proto, const char *send_buffer, char *recv_buffer, int | |||
339 | if (recv_result == -1) { | 339 | if (recv_result == -1) { |
340 | strcpy (recv_buffer, ""); | 340 | strcpy (recv_buffer, ""); |
341 | if (proto != IPPROTO_TCP) | 341 | if (proto != IPPROTO_TCP) |
342 | printf ("Receive failed\n"); | 342 | printf (_("Receive failed\n")); |
343 | result = STATE_WARNING; | 343 | result = STATE_WARNING; |
344 | } | 344 | } |
345 | else | 345 | else |
diff --git a/plugins/popen.c b/plugins/popen.c index 94ad583f..04eb3881 100644 --- a/plugins/popen.c +++ b/plugins/popen.c | |||
@@ -114,7 +114,7 @@ spopen (const char *cmdstring) | |||
114 | argv = malloc (sizeof(char*)*argc); | 114 | argv = malloc (sizeof(char*)*argc); |
115 | 115 | ||
116 | if (argv == NULL) { | 116 | if (argv == NULL) { |
117 | printf ("Could not malloc argv array in popen()\n"); | 117 | printf (_("Could not malloc argv array in popen()\n")); |
118 | return NULL; | 118 | return NULL; |
119 | } | 119 | } |
120 | 120 | ||
@@ -124,7 +124,7 @@ spopen (const char *cmdstring) | |||
124 | str += strspn (str, " \t\r\n"); /* trim any leading whitespace */ | 124 | str += strspn (str, " \t\r\n"); /* trim any leading whitespace */ |
125 | 125 | ||
126 | if (i >= argc - 2) { | 126 | if (i >= argc - 2) { |
127 | printf ("CRITICAL - You need more args!!!\n"); | 127 | printf (_("CRITICAL - You need more args!!!\n")); |
128 | return (NULL); | 128 | return (NULL); |
129 | } | 129 | } |
130 | 130 | ||
@@ -239,17 +239,19 @@ static int openmax = 0; | |||
239 | #define OPEN_MAX_GUESS 256 /* if OPEN_MAX is indeterminate */ | 239 | #define OPEN_MAX_GUESS 256 /* if OPEN_MAX is indeterminate */ |
240 | /* no guarantee this is adequate */ | 240 | /* no guarantee this is adequate */ |
241 | 241 | ||
242 | |||
242 | void | 243 | void |
243 | popen_timeout_alarm_handler (int signo) | 244 | popen_timeout_alarm_handler (int signo) |
244 | { | 245 | { |
245 | if (signo == SIGALRM) { | 246 | if (signo == SIGALRM) { |
246 | kill (childpid[fileno (child_process)], SIGKILL); | 247 | kill (childpid[fileno (child_process)], SIGKILL); |
247 | printf ("CRITICAL - Plugin timed out after %d seconds\n", | 248 | printf (_("CRITICAL - Plugin timed out after %d seconds\n"), |
248 | timeout_interval); | 249 | timeout_interval); |
249 | exit (STATE_CRITICAL); | 250 | exit (STATE_CRITICAL); |
250 | } | 251 | } |
251 | } | 252 | } |
252 | 253 | ||
254 | |||
253 | int | 255 | int |
254 | open_max (void) | 256 | open_max (void) |
255 | { | 257 | { |
@@ -259,14 +261,13 @@ open_max (void) | |||
259 | if (errno == 0) | 261 | if (errno == 0) |
260 | openmax = OPEN_MAX_GUESS; /* it's indeterminate */ | 262 | openmax = OPEN_MAX_GUESS; /* it's indeterminate */ |
261 | else | 263 | else |
262 | err_sys ("sysconf error for _SC_OPEN_MAX"); | 264 | err_sys (_("sysconf error for _SC_OPEN_MAX")); |
263 | } | 265 | } |
264 | } | 266 | } |
265 | return (openmax); | 267 | return (openmax); |
266 | } | 268 | } |
267 | 269 | ||
268 | 270 | ||
269 | |||
270 | /* Fatal error related to a system call. | 271 | /* Fatal error related to a system call. |
271 | * Print a message and die. */ | 272 | * Print a message and die. */ |
272 | 273 | ||
@@ -309,4 +310,3 @@ rtrim (char *str, const char *tok) | |||
309 | } | 310 | } |
310 | return str; | 311 | return str; |
311 | } | 312 | } |
312 | |||
diff --git a/plugins/popen.h b/plugins/popen.h index b7585792..1f4e413a 100644 --- a/plugins/popen.h +++ b/plugins/popen.h | |||
@@ -1,3 +1,9 @@ | |||
1 | /****************************************************************************** | ||
2 | * | ||
3 | * $Id$ | ||
4 | * | ||
5 | ******************************************************************************/ | ||
6 | |||
1 | FILE *spopen (const char *); | 7 | FILE *spopen (const char *); |
2 | int spclose (FILE *); | 8 | int spclose (FILE *); |
3 | RETSIGTYPE popen_timeout_alarm_handler (int); | 9 | RETSIGTYPE popen_timeout_alarm_handler (int); |
diff --git a/plugins/urlize.c b/plugins/urlize.c index 3564e469..96bbdc00 100644 --- a/plugins/urlize.c +++ b/plugins/urlize.c | |||
@@ -71,9 +71,7 @@ main (int argc, char **argv) | |||
71 | break; | 71 | break; |
72 | case '?': | 72 | case '?': |
73 | default: | 73 | default: |
74 | printf (_("%s: Unknown argument: %s\n\n"), progname, optarg); | 74 | usage2 (_("Unknown argument"), optarg); |
75 | print_usage (); | ||
76 | exit (STATE_UNKNOWN); | ||
77 | } | 75 | } |
78 | } | 76 | } |
79 | 77 | ||
diff --git a/plugins/utils.c b/plugins/utils.c index b2948e65..b9a19d3f 100644 --- a/plugins/utils.c +++ b/plugins/utils.c | |||
@@ -53,7 +53,7 @@ max_state (int a, int b) | |||
53 | 53 | ||
54 | void usage (const char *msg) | 54 | void usage (const char *msg) |
55 | { | 55 | { |
56 | printf ("%s", msg); | 56 | printf ("%s\n", msg); |
57 | print_usage (); | 57 | print_usage (); |
58 | exit (STATE_UNKNOWN); | 58 | exit (STATE_UNKNOWN); |
59 | } | 59 | } |
@@ -133,7 +133,7 @@ void | |||
133 | timeout_alarm_handler (int signo) | 133 | timeout_alarm_handler (int signo) |
134 | { | 134 | { |
135 | if (signo == SIGALRM) { | 135 | if (signo == SIGALRM) { |
136 | printf ("CRITICAL - Plugin timed out after %d seconds\n", | 136 | printf (_("CRITICAL - Plugin timed out after %d seconds\n"), |
137 | timeout_interval); | 137 | timeout_interval); |
138 | exit (STATE_CRITICAL); | 138 | exit (STATE_CRITICAL); |
139 | } | 139 | } |
@@ -430,7 +430,7 @@ strpcpy (char *dest, const char *src, const char *str) | |||
430 | if (dest == NULL || strlen (dest) < len) | 430 | if (dest == NULL || strlen (dest) < len) |
431 | dest = realloc (dest, len + 1); | 431 | dest = realloc (dest, len + 1); |
432 | if (dest == NULL) | 432 | if (dest == NULL) |
433 | die (STATE_UNKNOWN, "failed realloc in strpcpy\n"); | 433 | die (STATE_UNKNOWN, _("failed realloc in strpcpy\n")); |
434 | 434 | ||
435 | strncpy (dest, src, len); | 435 | strncpy (dest, src, len); |
436 | dest[len] = '\0'; | 436 | dest[len] = '\0'; |
@@ -472,7 +472,7 @@ strpcat (char *dest, const char *src, const char *str) | |||
472 | 472 | ||
473 | dest = realloc (dest, len + l2 + 1); | 473 | dest = realloc (dest, len + l2 + 1); |
474 | if (dest == NULL) | 474 | if (dest == NULL) |
475 | die (STATE_UNKNOWN, "failed malloc in strscat\n"); | 475 | die (STATE_UNKNOWN, _("failed malloc in strscat\n")); |
476 | 476 | ||
477 | strncpy (dest + len, src, l2); | 477 | strncpy (dest + len, src, l2); |
478 | dest[len + l2] = '\0'; | 478 | dest[len + l2] = '\0'; |