plugins/check_nwstat.c

   1 /*****************************************************************************
   2 *
   3 * Nagios check_nwstat plugin
   4 *
   5 * License: GPL
   6 * Copyright (c) 2000-2007 Nagios Plugins Development Team
   7 *
   8 * Last Modified: $Date$
   9 *
  10 * Description:
  11 *
  12 * This file contains the check_nwstat plugin
  13 *
  14 * This plugin attempts to contact the MRTGEXT NLM running on a
  15 * Novell server to gather the requested system information.
  16 *
  17 *
  18 * This program is free software: you can redistribute it and/or modify
  19 * it under the terms of the GNU General Public License as published by
  20 * the Free Software Foundation, either version 3 of the License, or
  21 * (at your option) any later version.
  22 *
  23 * This program is distributed in the hope that it will be useful,
  24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 * GNU General Public License for more details.
  27 *
  28 * You should have received a copy of the GNU General Public License
  29 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  30 *
  31 * $Id$
  32 *
  33 *****************************************************************************/
  34
  35 const char *progname = "check_nwstat";
  36 const char *revision = "$Revision$";
  37 const char *copyright = "2000-2007";
  38 const char *email = "nagiosplug-devel@lists.sourceforge.net";
  39
  40 #include "common.h"
  41 #include "netutils.h"
  42 #include "utils.h"
  43
  44 enum checkvar {
  45         NONE,
  46         LOAD1,      /* check 1 minute CPU load */
  47         LOAD5,      /* check 5 minute CPU load */
  48         LOAD15,     /* check 15 minute CPU load */
  49         CONNS,      /* check number of connections */
  50         VPF,        /* check % free space on volume */
  51         VMF,        /* check MB free space on volume */
  52         VMU,        /* check MB used space on volume */
  53         VMP,        /* check MB purgeable space on volume */
  54         VKF,        /* check KB free space on volume */
  55         LTCH,       /* check long-term cache hit percentage */
  56         CBUFF,      /* check total cache buffers */
  57         CDBUFF,     /* check dirty cache buffers */
  58         LRUM,       /* check LRU sitting time in minutes */
  59         DSDB,       /* check to see if DS Database is open */
  60         LOGINS,     /* check to see if logins are enabled */
  61         NRMH,       /* check to see NRM Health Status */
  62         PUPRB,      /* check % of used packet receive buffers */
  63         UPRB,       /* check used packet receive buffers */
  64         SAPENTRIES, /* check SAP entries */
  65         OFILES,     /* check number of open files */
  66         VKP,        /* check KB purgeable space on volume */
  67         VPP,        /* check % purgeable space on volume */
  68         VKNP,       /* check KB not yet purgeable space on volume */
  69         VPNP,       /* check % not yet purgeable space on volume */
  70         ABENDS,     /* check abended thread count */
  71         CSPROCS,    /* check number of current service processes */
  72         TSYNC,      /* check timesync status 0=no 1=yes in sync to the network */
  73         LRUS,       /* check LRU sitting time in seconds */
  74         DCB,        /* check dirty cache buffers as a percentage of the total */
  75         TCB,        /* check total cache buffers as a percentage of the original */
  76         DSVER,      /* check NDS version */
  77         UPTIME,     /* check server uptime */
  78         NLM,        /* check NLM loaded */
  79         NRMP,       /* check NRM Process Values */
  80         NRMM,       /* check NRM Memory Values */
  81         NRMS,       /* check NRM Values */
  82         NSS1,       /* check Statistics from _Admin:Manage_NSS\GeneralStats.xml */
  83         NSS2,       /* check Statistics from _Admin:Manage_NSS\BufferCache.xml */
  84         NSS3,       /* check statistics from _Admin:Manage_NSS\NameCache.xml */
  85         NSS4,       /* check statistics from _Admin:Manage_NSS\FileStats.xml */
  86         NSS5,       /* check statistics from _Admin:Manage_NSS\ObjectCache.xml */
  87         NSS6,       /* check statistics from _Admin:Manage_NSS\Thread.xml */
  88         NSS7        /* check statistics from _Admin:Manage_NSS\AuthorizationCache.xml */
  89 };
  90
  91 enum {
  92         PORT = 9999
  93 };
  94
  95 char *server_address=NULL;
  96 char *volume_name=NULL;
  97 char *nlm_name=NULL;
  98 char *nrmp_name=NULL;
  99 char *nrmm_name=NULL;
 100 char *nrms_name=NULL;
 101 char *nss1_name=NULL;
 102 char *nss2_name=NULL;
 103 char *nss3_name=NULL;
 104 char *nss4_name=NULL;
 105 char *nss5_name=NULL;
 106 char *nss6_name=NULL;
 107 char *nss7_name=NULL;
 108 int server_port=PORT;
 109 unsigned long warning_value=0L;
 110 unsigned long critical_value=0L;
 111 int check_warning_value=FALSE;
 112 int check_critical_value=FALSE;
 113 int check_netware_version=FALSE;
 114 enum checkvar vars_to_check = NONE;
 115 int sap_number=-1;
 116
 117 int process_arguments(int, char **);
 118 void print_help(void);
 119 void print_usage(void);
 120
 121
 122
 123 int
 124 main(int argc, char **argv) {
 125         int result = STATE_UNKNOWN;
 126         int sd;
 127         char *send_buffer=NULL;
 128         char recv_buffer[MAX_INPUT_BUFFER];
 129         char *output_message=NULL;
 130         char *temp_buffer=NULL;
 131         char *netware_version=NULL;
 132
 133         int time_sync_status=0;
 134         int nrm_health_status=0;
 135         unsigned long total_cache_buffers=0;
 136         unsigned long dirty_cache_buffers=0;
 137         unsigned long open_files=0;
 138         unsigned long abended_threads=0;
 139         unsigned long max_service_processes=0;
 140         unsigned long current_service_processes=0;
 141         unsigned long free_disk_space=0L;
 142         unsigned long nrmp_value=0L;
 143         unsigned long nrmm_value=0L;
 144         unsigned long nrms_value=0L;
 145         unsigned long nss1_value=0L;
 146         unsigned long nss2_value=0L;
 147         unsigned long nss3_value=0L;
 148         unsigned long nss4_value=0L;
 149         unsigned long nss5_value=0L;
 150         unsigned long nss6_value=0L;
 151         unsigned long nss7_value=0L;
 152         unsigned long total_disk_space=0L;
 153         unsigned long purgeable_disk_space=0L;
 154         unsigned long non_purgeable_disk_space=0L;
 155         unsigned long percent_free_space=0;
 156         unsigned long percent_purgeable_space=0;
 157         unsigned long percent_non_purgeable_space=0;
 158         unsigned long current_connections=0L;
 159         unsigned long utilization=0L;
 160         unsigned long cache_hits=0;
 161         unsigned long cache_buffers=0L;
 162         unsigned long lru_time=0L;
 163         unsigned long max_packet_receive_buffers=0;
 164         unsigned long used_packet_receive_buffers=0;
 165         unsigned long percent_used_packet_receive_buffers=0L;
 166         unsigned long sap_entries=0;
 167         char uptime[MAX_INPUT_BUFFER];
 168
 169         setlocale (LC_ALL, "");
 170         bindtextdomain (PACKAGE, LOCALEDIR);
 171         textdomain (PACKAGE);
 172
 173         if (process_arguments(argc,argv) == ERROR)
 174                 usage4 (_("Could not parse arguments"));
 175
 176         /* initialize alarm signal handling */
 177         signal(SIGALRM,socket_timeout_alarm_handler);
 178
 179         /* set socket timeout */
 180         alarm(socket_timeout);
 181
 182         /* open connection */
 183         my_tcp_connect (server_address, server_port, &sd);
 184
 185         /* get OS version string */
 186         if (check_netware_version==TRUE) {
 187                 send_buffer = strdup ("S19\r\n");
 188                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 189                 if (result!=STATE_OK)
 190                         return result;
 191                 if (!strcmp(recv_buffer,"-1\n"))
 192                         netware_version = strdup("");
 193                 else {
 194                         recv_buffer[strlen(recv_buffer)-1]=0;
 195                         asprintf (&netware_version,_("NetWare %s: "),recv_buffer);
 196                 }
 197         } else
 198                 netware_version = strdup("");
 199
 200
 201         /* check CPU load */
 202         if (vars_to_check==LOAD1 || vars_to_check==LOAD5 || vars_to_check==LOAD15) {
 203
 204                 switch(vars_to_check) {
 205                 case LOAD1:
 206                         temp_buffer = strdup ("1");
 207                         break;
 208                 case LOAD5:
 209                         temp_buffer = strdup ("5");
 210                         break;
 211                 default:
 212                         temp_buffer = strdup ("15");
 213                         break;
 214                 }
 215
 216                 close(sd);
 217                 my_tcp_connect (server_address, server_port, &sd);
 218
 219                 asprintf (&send_buffer,"UTIL%s\r\n",temp_buffer);
 220                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 221                 if (result!=STATE_OK)
 222                         return result;
 223                 utilization=strtoul(recv_buffer,NULL,10);
 224
 225                 close(sd);
 226                 my_tcp_connect (server_address, server_port, &sd);
 227
 228                 send_buffer = strdup ("UPTIME\r\n");
 229                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 230                 if (result!=STATE_OK)
 231                         return result;
 232                 recv_buffer[strlen(recv_buffer)-1]=0;
 233                 sprintf(uptime,_("Up %s,"),recv_buffer);
 234
 235                 if (check_critical_value==TRUE && utilization >= critical_value)
 236                         result=STATE_CRITICAL;
 237                 else if (check_warning_value==TRUE && utilization >= warning_value)
 238                         result=STATE_WARNING;
 239
 240                 asprintf (&output_message,
 241                           _("Load %s - %s %s-min load average = %lu%%|load%s=%lu;%lu;%lu;0;100"),
 242                           state_text(result),
 243                           uptime,
 244                           temp_buffer,
 245                           utilization,
 246                           temp_buffer,
 247                           utilization,
 248                           warning_value,
 249                           critical_value);
 250
 251                 /* check number of user connections */
 252         } else if (vars_to_check==CONNS) {
 253
 254                 close(sd);
 255                 my_tcp_connect (server_address, server_port, &sd);
 256
 257                 send_buffer = strdup ("CONNECT\r\n");
 258                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 259                 if (result!=STATE_OK)
 260                         return result;
 261                 current_connections=strtoul(recv_buffer,NULL,10);
 262
 263                 if (check_critical_value==TRUE && current_connections >= critical_value)
 264                         result=STATE_CRITICAL;
 265                 else if (check_warning_value==TRUE && current_connections >= warning_value)
 266                         result=STATE_WARNING;
 267
 268                 asprintf (&output_message,
 269                         _("Conns %s - %lu current connections|Conns=%lu;%lu;%lu;;"),
 270                           state_text(result),
 271                           current_connections,
 272                           current_connections,
 273                           warning_value,
 274                           critical_value);
 275
 276                 /* check % long term cache hits */
 277         } else if (vars_to_check==LTCH) {
 278
 279                 close(sd);
 280                 my_tcp_connect (server_address, server_port, &sd);
 281
 282                 send_buffer = strdup ("S1\r\n");
 283                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 284                 if (result!=STATE_OK)
 285                         return result;
 286                 cache_hits=atoi(recv_buffer);
 287
 288                 if (check_critical_value==TRUE && cache_hits <= critical_value)
 289                         result=STATE_CRITICAL;
 290                 else if (check_warning_value==TRUE && cache_hits <= warning_value)
 291                         result=STATE_WARNING;
 292
 293                 asprintf (&output_message,
 294                           _("%s: Long term cache hits = %lu%%"),
 295                           state_text(result),
 296                           cache_hits);
 297
 298                 /* check cache buffers */
 299         } else if (vars_to_check==CBUFF) {
 300
 301                 close(sd);
 302                 my_tcp_connect (server_address, server_port, &sd);
 303
 304                 send_buffer = strdup ("S2\r\n");
 305                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 306                 if (result!=STATE_OK)
 307                         return result;
 308                 cache_buffers=strtoul(recv_buffer,NULL,10);
 309
 310                 if (check_critical_value==TRUE && cache_buffers <= critical_value)
 311                         result=STATE_CRITICAL;
 312                 else if (check_warning_value==TRUE && cache_buffers <= warning_value)
 313                         result=STATE_WARNING;
 314
 315                 asprintf (&output_message,
 316                           _("%s: Total cache buffers = %lu|Cachebuffers=%lu;%lu;%lu;;"),
 317                           state_text(result),
 318                           cache_buffers,
 319                           cache_buffers,
 320                           warning_value,
 321                           critical_value);
 322
 323                 /* check dirty cache buffers */
 324         } else if (vars_to_check==CDBUFF) {
 325
 326                 close(sd);
 327                 my_tcp_connect (server_address, server_port, &sd);
 328
 329                 send_buffer = strdup ("S3\r\n");
 330                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 331                 if (result!=STATE_OK)
 332                         return result;
 333                 cache_buffers=strtoul(recv_buffer,NULL,10);
 334
 335                 if (check_critical_value==TRUE && cache_buffers >= critical_value)
 336                         result=STATE_CRITICAL;
 337                 else if (check_warning_value==TRUE && cache_buffers >= warning_value)
 338                         result=STATE_WARNING;
 339
 340                 asprintf (&output_message,
 341                           _("%s: Dirty cache buffers = %lu|Dirty-Cache-Buffers=%lu;%lu;%lu;;"),
 342                           state_text(result),
 343                           cache_buffers,
 344                           cache_buffers,
 345                           warning_value,
 346                           critical_value);
 347
 348                 /* check LRU sitting time in minutes */
 349         } else if (vars_to_check==LRUM) {
 350
 351                 close(sd);
 352                 my_tcp_connect (server_address, server_port, &sd);
 353
 354                 send_buffer = strdup ("S5\r\n");
 355                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 356                 if (result!=STATE_OK)
 357                         return result;
 358                 lru_time=strtoul(recv_buffer,NULL,10);
 359
 360                 if (check_critical_value==TRUE && lru_time <= critical_value)
 361                         result=STATE_CRITICAL;
 362                 else if (check_warning_value==TRUE && lru_time <= warning_value)
 363                         result=STATE_WARNING;
 364
 365                 asprintf (&output_message,
 366                           _("%s: LRU sitting time = %lu minutes"),
 367                           state_text(result),
 368                           lru_time);
 369
 370
 371                 /* check KB free space on volume */
 372         } else if (vars_to_check==VKF) {
 373
 374                 close(sd);
 375                 my_tcp_connect (server_address, server_port, &sd);
 376
 377                 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
 378                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 379                 if (result!=STATE_OK)
 380                         return result;
 381
 382                 if (!strcmp(recv_buffer,"-1\n")) {
 383                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 384                         result=STATE_CRITICAL;
 385                 }       else {
 386                         free_disk_space=strtoul(recv_buffer,NULL,10);
 387                         if (check_critical_value==TRUE && free_disk_space <= critical_value)
 388                                 result=STATE_CRITICAL;
 389                         else if (check_warning_value==TRUE && free_disk_space <= warning_value)
 390                                 result=STATE_WARNING;
 391                         asprintf (&output_message,
 392                                   _("%s%lu KB free on volume %s|KBFree%s=%lu;%lu;%lu;;"),
 393                                  (result==STATE_OK)?"":_("Only "),
 394                                  free_disk_space,
 395                                  volume_name,
 396                                  volume_name,
 397                                  free_disk_space,
 398                                  warning_value,
 399                                  critical_value);
 400                 }
 401
 402                 /* check MB free space on volume */
 403         } else if (vars_to_check==VMF) {
 404
 405                 asprintf (&send_buffer,"VMF%s\r\n",volume_name);
 406                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 407                 if (result!=STATE_OK)
 408                         return result;
 409
 410                 if (!strcmp(recv_buffer,"-1\n")) {
 411                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 412                         result=STATE_CRITICAL;
 413                 }       else {
 414                         free_disk_space=strtoul(recv_buffer,NULL,10);
 415                         if (check_critical_value==TRUE && free_disk_space <= critical_value)
 416                                 result=STATE_CRITICAL;
 417                         else if (check_warning_value==TRUE && free_disk_space <= warning_value)
 418                                 result=STATE_WARNING;
 419                         asprintf (&output_message,
 420                                   _("%s%lu MB free on volume %s|MBFree%s=%lu;%lu;%lu;;"),
 421                                  (result==STATE_OK)?"":_("Only "),
 422                                  free_disk_space,
 423                                  volume_name,
 424                                  volume_name,
 425                                  free_disk_space,
 426                                  warning_value,
 427                                  critical_value);
 428                 }
 429                 /* check MB used space on volume */
 430         } else if (vars_to_check==VMU) {
 431
 432                 asprintf (&send_buffer,"VMU%s\r\n",volume_name);
 433                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 434                 if (result!=STATE_OK)
 435                         return result;
 436
 437                 if (!strcmp(recv_buffer,"-1\n")) {
 438                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 439                         result=STATE_CRITICAL;
 440                 }       else {
 441                         free_disk_space=strtoul(recv_buffer,NULL,10);
 442                         if (check_critical_value==TRUE && free_disk_space <= critical_value)
 443                                 result=STATE_CRITICAL;
 444                         else if (check_warning_value==TRUE && free_disk_space <= warning_value)
 445                                 result=STATE_WARNING;
 446                         asprintf (&output_message,
 447                                   _("%s%lu MB used on volume %s|MBUsed%s=%lu;%lu;%lu;;"),
 448                                  (result==STATE_OK)?"":_("Only "),
 449                                  free_disk_space,
 450                                  volume_name,
 451                                  volume_name,
 452                                  free_disk_space,
 453                                  warning_value,
 454                                  critical_value);
 455                 }
 456
 457
 458                 /* check % free space on volume */
 459         } else if (vars_to_check==VPF) {
 460
 461                 close(sd);
 462                 my_tcp_connect (server_address, server_port, &sd);
 463
 464                 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
 465                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 466                 if (result!=STATE_OK)
 467                         return result;
 468
 469                 if (!strcmp(recv_buffer,"-1\n")) {
 470
 471                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 472                         result=STATE_CRITICAL;
 473
 474                 } else {
 475
 476                         free_disk_space=strtoul(recv_buffer,NULL,10);
 477
 478                         close(sd);
 479                         my_tcp_connect (server_address, server_port, &sd);
 480
 481                         asprintf (&send_buffer,"VKS%s\r\n",volume_name);
 482                         result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 483                         if (result!=STATE_OK)
 484                                 return result;
 485                         total_disk_space=strtoul(recv_buffer,NULL,10);
 486
 487                         percent_free_space=(unsigned long)(((double)free_disk_space/(double)total_disk_space)*100.0);
 488
 489                         if (check_critical_value==TRUE && percent_free_space <= critical_value)
 490                                 result=STATE_CRITICAL;
 491                         else if (check_warning_value==TRUE && percent_free_space <= warning_value)
 492                                 result=STATE_WARNING;
 493                         free_disk_space/=1024;
 494                         total_disk_space/=1024;
 495                         asprintf (&output_message,_("%lu MB (%lu%%) free on volume %s - total %lu MB|FreeMB%s=%lu;%lu;%lu;0;100"),
 496                                 free_disk_space,
 497                                 percent_free_space,
 498                                 volume_name,
 499                                 total_disk_space,
 500                                 volume_name,
 501                                 percent_free_space,
 502                                 warning_value,
 503                                 critical_value
 504                                 );
 505                 }
 506
 507                 /* check to see if DS Database is open or closed */
 508         } else if (vars_to_check==DSDB) {
 509
 510                 close(sd);
 511                 my_tcp_connect (server_address, server_port, &sd);
 512
 513                 send_buffer = strdup ("S11\r\n");
 514                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 515                 if (result!=STATE_OK)
 516                         return result;
 517                 if (atoi(recv_buffer)==1)
 518                         result=STATE_OK;
 519                 else
 520                         result=STATE_WARNING;
 521
 522                 close(sd);
 523                 my_tcp_connect (server_address, server_port, &sd);
 524
 525                 send_buffer = strdup ("S13\r\n");
 526                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 527                 temp_buffer=strtok(recv_buffer,"\r\n");
 528
 529                 asprintf (&output_message,_("Directory Services Database is %s (DS version %s)"),(result==STATE_OK)?"open":"closed",temp_buffer);
 530
 531                 /* check to see if logins are enabled */
 532         } else if (vars_to_check==LOGINS) {
 533
 534                 close(sd);
 535                 my_tcp_connect (server_address, server_port, &sd);
 536
 537                 send_buffer = strdup ("S12\r\n");
 538                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 539                 if (result!=STATE_OK)
 540                         return result;
 541                 if (atoi(recv_buffer)==1)
 542                         result=STATE_OK;
 543                 else
 544                         result=STATE_WARNING;
 545
 546                 asprintf (&output_message,_("Logins are %s"),(result==STATE_OK)?_("enabled"):_("disabled"));
 547
 548
 549                 /* check NRM Health Status Summary*/
 550         } else if (vars_to_check==NRMH) {
 551
 552                 asprintf (&send_buffer,"NRMH\r\n");
 553                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 554                 if (result!=STATE_OK)
 555                         return result;
 556
 557                 nrm_health_status=atoi(recv_buffer);
 558
 559                 if (nrm_health_status==2) {
 560                         result=STATE_OK;
 561                         asprintf (&output_message,_("CRITICAL - NRM Status is bad!"));
 562                 }
 563                 else {
 564                         if (nrm_health_status==1) {
 565                                 result=STATE_WARNING;
 566                                 asprintf (&output_message,_("Warning - NRM Status is suspect!"));
 567                         }
 568
 569                         asprintf (&output_message,_("OK - NRM Status is good!"));
 570                 }
 571
 572
 573
 574                 /* check packet receive buffers */
 575         } else if (vars_to_check==UPRB || vars_to_check==PUPRB) {
 576
 577                 close(sd);
 578                 my_tcp_connect (server_address, server_port, &sd);
 579
 580                 asprintf (&send_buffer,"S15\r\n");
 581                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 582                 if (result!=STATE_OK)
 583                         return result;
 584
 585                 used_packet_receive_buffers=atoi(recv_buffer);
 586
 587                 close(sd);
 588                 my_tcp_connect (server_address, server_port, &sd);
 589
 590                 asprintf (&send_buffer,"S16\r\n");
 591                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 592                 if (result!=STATE_OK)
 593                         return result;
 594
 595                 max_packet_receive_buffers=atoi(recv_buffer);
 596
 597                 percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
 598
 599                 if (vars_to_check==UPRB) {
 600                         if (check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
 601                                 result=STATE_CRITICAL;
 602                         else if (check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
 603                                 result=STATE_WARNING;
 604                 } else {
 605                         if (check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
 606                                 result=STATE_CRITICAL;
 607                         else if (check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
 608                                 result=STATE_WARNING;
 609                 }
 610
 611                 asprintf (&output_message,_("%lu of %lu (%lu%%) packet receive buffers used"),used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
 612
 613                 /* check SAP table entries */
 614         } else if (vars_to_check==SAPENTRIES) {
 615
 616                 close(sd);
 617                 my_tcp_connect (server_address, server_port, &sd);
 618
 619                 if (sap_number==-1)
 620                         asprintf (&send_buffer,"S9\r\n");
 621                 else
 622                         asprintf (&send_buffer,"S9.%d\r\n",sap_number);
 623                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 624                 if (result!=STATE_OK)
 625                         return result;
 626
 627                 sap_entries=atoi(recv_buffer);
 628
 629                 if (check_critical_value==TRUE && sap_entries >= critical_value)
 630                         result=STATE_CRITICAL;
 631                 else if (check_warning_value==TRUE && sap_entries >= warning_value)
 632                         result=STATE_WARNING;
 633
 634                 if (sap_number==-1)
 635                         asprintf (&output_message,_("%lu entries in SAP table"),sap_entries);
 636                 else
 637                         asprintf (&output_message,_("%lu entries in SAP table for SAP type %d"),sap_entries,sap_number);
 638
 639                 /* check KB purgeable space on volume */
 640         } else if (vars_to_check==VKP) {
 641
 642                 close(sd);
 643                 my_tcp_connect (server_address, server_port, &sd);
 644
 645                 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
 646                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 647                 if (result!=STATE_OK)
 648                         return result;
 649
 650                 if (!strcmp(recv_buffer,"-1\n")) {
 651                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 652                         result=STATE_CRITICAL;
 653                 } else {
 654                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 655                         if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
 656                                 result=STATE_CRITICAL;
 657                         else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
 658                                 result=STATE_WARNING;
 659                         asprintf (&output_message,_("%s%lu KB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"),
 660                                  (result==STATE_OK)?"":_("Only "),
 661                                  purgeable_disk_space,
 662                                  volume_name,
 663                                  volume_name,
 664                                  purgeable_disk_space,
 665                                  warning_value,
 666                                  critical_value);
 667                 }
 668                 /* check MB purgeable space on volume */
 669         } else if (vars_to_check==VMP) {
 670
 671                 asprintf (&send_buffer,"VMP%s\r\n",volume_name);
 672                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 673                 if (result!=STATE_OK)
 674                         return result;
 675
 676                 if (!strcmp(recv_buffer,"-1\n")) {
 677                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 678                         result=STATE_CRITICAL;
 679                 } else {
 680                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 681                         if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
 682                                 result=STATE_CRITICAL;
 683                         else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
 684                                 result=STATE_WARNING;
 685                         asprintf (&output_message,_("%s%lu MB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"),
 686                                  (result==STATE_OK)?"":_("Only "),
 687                                  purgeable_disk_space,
 688                                  volume_name,
 689                                  volume_name,
 690                                  purgeable_disk_space,
 691                                  warning_value,
 692                                  critical_value);
 693                 }
 694
 695                 /* check % purgeable space on volume */
 696         } else if (vars_to_check==VPP) {
 697
 698                 close(sd);
 699                 my_tcp_connect (server_address, server_port, &sd);
 700
 701                 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
 702                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 703                 if (result!=STATE_OK)
 704                         return result;
 705
 706                 if (!strcmp(recv_buffer,"-1\n")) {
 707
 708                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 709                         result=STATE_CRITICAL;
 710
 711                 } else {
 712
 713                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 714
 715                         close(sd);
 716                         my_tcp_connect (server_address, server_port, &sd);
 717
 718                         asprintf (&send_buffer,"VKS%s\r\n",volume_name);
 719                         result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 720                         if (result!=STATE_OK)
 721                                 return result;
 722                         total_disk_space=strtoul(recv_buffer,NULL,10);
 723
 724                         percent_purgeable_space=(unsigned long)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
 725
 726                         if (check_critical_value==TRUE && percent_purgeable_space >= critical_value)
 727                                 result=STATE_CRITICAL;
 728                         else if (check_warning_value==TRUE && percent_purgeable_space >= warning_value)
 729                                 result=STATE_WARNING;
 730                         purgeable_disk_space/=1024;
 731                         asprintf (&output_message,_("%lu MB (%lu%%) purgeable on volume %s|Purgeable%s=%lu;%lu;%lu;0;100"),
 732                                         purgeable_disk_space,
 733                                         percent_purgeable_space,
 734                                         volume_name,
 735                                         volume_name,
 736                                         percent_purgeable_space,
 737                                         warning_value,
 738                                         critical_value
 739                                         );
 740                 }
 741
 742                 /* check KB not yet purgeable space on volume */
 743         } else if (vars_to_check==VKNP) {
 744
 745                 close(sd);
 746                 my_tcp_connect (server_address, server_port, &sd);
 747
 748                 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
 749                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 750                 if (result!=STATE_OK)
 751                         return result;
 752
 753                 if (!strcmp(recv_buffer,"-1\n")) {
 754                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 755                         result=STATE_CRITICAL;
 756                 } else {
 757                         non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 758                         if (check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
 759                                 result=STATE_CRITICAL;
 760                         else if (check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
 761                                 result=STATE_WARNING;
 762                         asprintf (&output_message,_("%s%lu KB not yet purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),non_purgeable_disk_space,volume_name);
 763                 }
 764
 765                 /* check % not yet purgeable space on volume */
 766         } else if (vars_to_check==VPNP) {
 767
 768                 close(sd);
 769                 my_tcp_connect (server_address, server_port, &sd);
 770
 771                 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
 772                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 773                 if (result!=STATE_OK)
 774                         return result;
 775
 776                 if (!strcmp(recv_buffer,"-1\n")) {
 777
 778                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 779                         result=STATE_CRITICAL;
 780
 781                 } else {
 782
 783                         non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 784
 785                         close(sd);
 786                         my_tcp_connect (server_address, server_port, &sd);
 787
 788                         asprintf (&send_buffer,"VKS%s\r\n",volume_name);
 789                         result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 790                         if (result!=STATE_OK)
 791                                 return result;
 792                         total_disk_space=strtoul(recv_buffer,NULL,10);
 793
 794                         percent_non_purgeable_space=(unsigned long)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
 795
 796                         if (check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
 797                                 result=STATE_CRITICAL;
 798                         else if (check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
 799                                 result=STATE_WARNING;
 800                         purgeable_disk_space/=1024;
 801                         asprintf (&output_message,_("%lu MB (%lu%%) not yet purgeable on volume %s"),non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
 802                 }
 803
 804                 /* check # of open files */
 805         } else if (vars_to_check==OFILES) {
 806
 807                 close(sd);
 808                 my_tcp_connect (server_address, server_port, &sd);
 809
 810                 asprintf (&send_buffer,"S18\r\n");
 811                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 812                 if (result!=STATE_OK)
 813                         return result;
 814
 815                 open_files=atoi(recv_buffer);
 816
 817                 if (check_critical_value==TRUE && open_files >= critical_value)
 818                         result=STATE_CRITICAL;
 819                 else if (check_warning_value==TRUE && open_files >= warning_value)
 820                         result=STATE_WARNING;
 821
 822                 asprintf (&output_message,_("%lu open files|Openfiles=%lu;%lu;%lu;0,0"),
 823                                 open_files,
 824                                 open_files,
 825                                 warning_value,
 826                                 critical_value);
 827
 828
 829                 /* check # of abended threads (Netware > 5.x only) */
 830         } else if (vars_to_check==ABENDS) {
 831
 832                 close(sd);
 833                 my_tcp_connect (server_address, server_port, &sd);
 834
 835                 asprintf (&send_buffer,"S17\r\n");
 836                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 837                 if (result!=STATE_OK)
 838                         return result;
 839
 840                 abended_threads=atoi(recv_buffer);
 841
 842                 if (check_critical_value==TRUE && abended_threads >= critical_value)
 843                         result=STATE_CRITICAL;
 844                 else if (check_warning_value==TRUE && abended_threads >= warning_value)
 845                         result=STATE_WARNING;
 846
 847                 asprintf (&output_message,_("%lu abended threads|Abends=%lu;%lu;%lu;;"),
 848                                 abended_threads,
 849                                 abended_threads,
 850                                 warning_value,
 851                                 critical_value);
 852
 853                 /* check # of current service processes (Netware 5.x only) */
 854         } else if (vars_to_check==CSPROCS) {
 855
 856                 close(sd);
 857                 my_tcp_connect (server_address, server_port, &sd);
 858
 859                 asprintf (&send_buffer,"S20\r\n");
 860                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 861                 if (result!=STATE_OK)
 862                         return result;
 863
 864                 max_service_processes=atoi(recv_buffer);
 865
 866                 close(sd);
 867                 my_tcp_connect (server_address, server_port, &sd);
 868
 869                 asprintf (&send_buffer,"S21\r\n");
 870                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 871                 if (result!=STATE_OK)
 872                         return result;
 873
 874                 current_service_processes=atoi(recv_buffer);
 875
 876                 if (check_critical_value==TRUE && current_service_processes >= critical_value)
 877                         result=STATE_CRITICAL;
 878                 else if (check_warning_value==TRUE && current_service_processes >= warning_value)
 879                         result=STATE_WARNING;
 880
 881                 asprintf (&output_message,
 882                           _("%lu current service processes (%lu max)|Processes=%lu;%lu;%lu;0;%lu"),
 883                           current_service_processes,
 884                           max_service_processes,
 885                           current_service_processes,
 886                           warning_value,
 887                           critical_value,
 888                           max_service_processes);
 889
 890                 /* check # Timesync Status */
 891         } else if (vars_to_check==TSYNC) {
 892
 893                 close(sd);
 894                 my_tcp_connect (server_address, server_port, &sd);
 895
 896                 asprintf (&send_buffer,"S22\r\n");
 897                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 898                 if (result!=STATE_OK)
 899                         return result;
 900
 901                 time_sync_status=atoi(recv_buffer);
 902
 903                 if (time_sync_status==0) {
 904                         result=STATE_CRITICAL;
 905                         asprintf (&output_message,_("CRITICAL - Time not in sync with network!"));
 906                 }
 907                 else {
 908                         asprintf (&output_message,_("OK - Time in sync with network!"));
 909                 }
 910
 911
 912
 913
 914
 915                 /* check LRU sitting time in secondss */
 916         } else if (vars_to_check==LRUS) {
 917
 918                 close(sd);
 919                 my_tcp_connect (server_address, server_port, &sd);
 920
 921                 send_buffer = strdup ("S4\r\n");
 922                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 923                 if (result!=STATE_OK)
 924                         return result;
 925                 lru_time=strtoul(recv_buffer,NULL,10);
 926
 927                 if (check_critical_value==TRUE && lru_time <= critical_value)
 928                         result=STATE_CRITICAL;
 929                 else if (check_warning_value==TRUE && lru_time <= warning_value)
 930                         result=STATE_WARNING;
 931                 asprintf (&output_message,_("LRU sitting time = %lu seconds"),lru_time);
 932
 933
 934                 /* check % dirty cacheobuffers as a percentage of the total*/
 935         } else if (vars_to_check==DCB) {
 936
 937                 close(sd);
 938                 my_tcp_connect (server_address, server_port, &sd);
 939
 940                 send_buffer = strdup ("S6\r\n");
 941                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 942                 if (result!=STATE_OK)
 943                         return result;
 944                 dirty_cache_buffers=atoi(recv_buffer);
 945
 946                 if (check_critical_value==TRUE && dirty_cache_buffers <= critical_value)
 947                         result=STATE_CRITICAL;
 948                 else if (check_warning_value==TRUE && dirty_cache_buffers <= warning_value)
 949                         result=STATE_WARNING;
 950                 asprintf (&output_message,_("Dirty cache buffers = %lu%% of the total|DCB=%lu;%lu;%lu;0;100"),
 951                                 dirty_cache_buffers,
 952                                 dirty_cache_buffers,
 953                                 warning_value,
 954                                 critical_value);
 955
 956                 /* check % total cache buffers as a percentage of the original*/
 957         } else if (vars_to_check==TCB) {
 958
 959                 close(sd);
 960                 my_tcp_connect (server_address, server_port, &sd);
 961
 962                 send_buffer = strdup ("S7\r\n");
 963                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 964                 if (result!=STATE_OK)
 965                         return result;
 966                 total_cache_buffers=atoi(recv_buffer);
 967
 968                 if (check_critical_value==TRUE && total_cache_buffers <= critical_value)
 969                         result=STATE_CRITICAL;
 970                 else if (check_warning_value==TRUE && total_cache_buffers <= warning_value)
 971                         result=STATE_WARNING;
 972                 asprintf (&output_message,_("Total cache buffers = %lu%% of the original|TCB=%lu;%lu;%lu;0;100"),
 973                                 total_cache_buffers,
 974                                 total_cache_buffers,
 975                                 warning_value,
 976                                 critical_value);
 977
 978         } else if (vars_to_check==DSVER) {
 979
 980                 close(sd);
 981                 my_tcp_connect (server_address, server_port, &sd);
 982
 983                 asprintf (&send_buffer,"S13\r\n");
 984                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 985                 if (result!=STATE_OK)
 986                         return result;
 987
 988                 recv_buffer[strlen(recv_buffer)-1]=0;
 989
 990                 asprintf (&output_message,_("NDS Version %s"),recv_buffer);
 991
 992         } else if (vars_to_check==UPTIME) {
 993
 994                 close(sd);
 995                 my_tcp_connect (server_address, server_port, &sd);
 996
 997                 asprintf (&send_buffer,"UPTIME\r\n");
 998                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 999                 if (result!=STATE_OK)
1000                         return result;
1001
1002
1003                 recv_buffer[sizeof(recv_buffer)-1]=0;
1004                 recv_buffer[strlen(recv_buffer)-1]=0;
1005
1006                 asprintf (&output_message,_("Up %s"),recv_buffer);
1007
1008         } else if (vars_to_check==NLM) {
1009
1010                 close(sd);
1011                 my_tcp_connect (server_address, server_port, &sd);
1012
1013                 asprintf (&send_buffer,"S24:%s\r\n",nlm_name);
1014                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1015                 if (result!=STATE_OK)
1016                         return result;
1017
1018                 recv_buffer[strlen(recv_buffer)-1]=0;
1019                 if (strcmp(recv_buffer,"-1")) {
1020                         asprintf (&output_message,_("Module %s version %s is loaded"),nlm_name,recv_buffer);
1021                 } else {
1022                         result=STATE_CRITICAL;
1023                         asprintf (&output_message,_("Module %s is not loaded"),nlm_name);
1024
1025                         }
1026         } else if (vars_to_check==NRMP) {
1027
1028                 asprintf (&send_buffer,"NRMP:%s\r\n",nrmp_name);
1029                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1030                 if (result!=STATE_OK)
1031                         return result;
1032
1033                 if (!strcmp(recv_buffer,"-1\n")) {
1034                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrmp_name);
1035                         result=STATE_CRITICAL;
1036                 }       else {
1037                         nrmp_value=strtoul(recv_buffer,NULL,10);
1038                         if (check_critical_value==TRUE && nrmp_value <= critical_value)
1039                                 result=STATE_CRITICAL;
1040                         else if (check_warning_value==TRUE && nrmp_value <= warning_value)
1041                                 result=STATE_WARNING;
1042                         asprintf (&output_message,
1043                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1044                                  nrmp_name,
1045                                  nrmp_value,
1046                                  nrmp_name,
1047                                  nrmp_value,
1048                                  warning_value,
1049                                  critical_value);
1050                 }
1051
1052         } else if (vars_to_check==NRMM) {
1053
1054                 asprintf (&send_buffer,"NRMM:%s\r\n",nrmm_name);
1055                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1056                 if (result!=STATE_OK)
1057                         return result;
1058
1059                 if (!strcmp(recv_buffer,"-1\n")) {
1060                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrmm_name);
1061                         result=STATE_CRITICAL;
1062                 }       else {
1063                         nrmm_value=strtoul(recv_buffer,NULL,10);
1064                         if (check_critical_value==TRUE && nrmm_value <= critical_value)
1065                                 result=STATE_CRITICAL;
1066                         else if (check_warning_value==TRUE && nrmm_value <= warning_value)
1067                                 result=STATE_WARNING;
1068                         asprintf (&output_message,
1069                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1070                                  nrmm_name,
1071                                  nrmm_value,
1072                                  nrmm_name,
1073                                  nrmm_value,
1074                                  warning_value,
1075                                  critical_value);
1076                 }
1077
1078         } else if (vars_to_check==NRMS) {
1079
1080                 asprintf (&send_buffer,"NRMS:%s\r\n",nrms_name);
1081                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1082                 if (result!=STATE_OK)
1083                         return result;
1084
1085                 if (!strcmp(recv_buffer,"-1\n")) {
1086                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrms_name);
1087                         result=STATE_CRITICAL;
1088                 }       else {
1089                         nrms_value=strtoul(recv_buffer,NULL,10);
1090                         if (check_critical_value==TRUE && nrms_value >= critical_value)
1091                                 result=STATE_CRITICAL;
1092                         else if (check_warning_value==TRUE && nrms_value >= warning_value)
1093                                 result=STATE_WARNING;
1094                         asprintf (&output_message,
1095                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1096                                  nrms_name,
1097                                  nrms_value,
1098                                  nrms_name,
1099                                  nrms_value,
1100                                  warning_value,
1101                                  critical_value);
1102                 }
1103
1104         } else if (vars_to_check==NSS1) {
1105
1106                 asprintf (&send_buffer,"NSS1:%s\r\n",nss1_name);
1107                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1108                 if (result!=STATE_OK)
1109                         return result;
1110
1111                 if (!strcmp(recv_buffer,"-1\n")) {
1112                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss1_name);
1113                         result=STATE_CRITICAL;
1114                 }       else {
1115                         nss1_value=strtoul(recv_buffer,NULL,10);
1116                         if (check_critical_value==TRUE && nss1_value >= critical_value)
1117                                 result=STATE_CRITICAL;
1118                         else if (check_warning_value==TRUE && nss1_value >= warning_value)
1119                                 result=STATE_WARNING;
1120                         asprintf (&output_message,
1121                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1122                                  nss1_name,
1123                                  nss1_value,
1124                                  nss1_name,
1125                                  nss1_value,
1126                                  warning_value,
1127                                  critical_value);
1128                 }
1129
1130         } else if (vars_to_check==NSS2) {
1131
1132                 asprintf (&send_buffer,"NSS2:%s\r\n",nss2_name);
1133                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1134                 if (result!=STATE_OK)
1135                         return result;
1136
1137                 if (!strcmp(recv_buffer,"-1\n")) {
1138                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss2_name);
1139                         result=STATE_CRITICAL;
1140                 }       else {
1141                         nss2_value=strtoul(recv_buffer,NULL,10);
1142                         if (check_critical_value==TRUE && nss2_value >= critical_value)
1143                                 result=STATE_CRITICAL;
1144                         else if (check_warning_value==TRUE && nss2_value >= warning_value)
1145                                 result=STATE_WARNING;
1146                         asprintf (&output_message,
1147                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1148                                  nss2_name,
1149                                  nss2_value,
1150                                  nss2_name,
1151                                  nss2_value,
1152                                  warning_value,
1153                                  critical_value);
1154                 }
1155
1156         } else if (vars_to_check==NSS3) {
1157
1158                 asprintf (&send_buffer,"NSS3:%s\r\n",nss3_name);
1159                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1160                 if (result!=STATE_OK)
1161                         return result;
1162
1163                 if (!strcmp(recv_buffer,"-1\n")) {
1164                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss3_name);
1165                         result=STATE_CRITICAL;
1166                 }       else {
1167                         nss3_value=strtoul(recv_buffer,NULL,10);
1168                         if (check_critical_value==TRUE && nss3_value >= critical_value)
1169                                 result=STATE_CRITICAL;
1170                         else if (check_warning_value==TRUE && nss3_value >= warning_value)
1171                                 result=STATE_WARNING;
1172                         asprintf (&output_message,
1173                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1174                                  nss3_name,
1175                                  nss3_value,
1176                                  nss3_name,
1177                                  nss3_value,
1178                                  warning_value,
1179                                  critical_value);
1180                 }
1181
1182         } else if (vars_to_check==NSS4) {
1183
1184                 asprintf (&send_buffer,"NSS4:%s\r\n",nss4_name);
1185                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1186                 if (result!=STATE_OK)
1187                         return result;
1188
1189                 if (!strcmp(recv_buffer,"-1\n")) {
1190                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss4_name);
1191                         result=STATE_CRITICAL;
1192                 }       else {
1193                         nss4_value=strtoul(recv_buffer,NULL,10);
1194                         if (check_critical_value==TRUE && nss4_value >= critical_value)
1195                                 result=STATE_CRITICAL;
1196                         else if (check_warning_value==TRUE && nss4_value >= warning_value)
1197                                 result=STATE_WARNING;
1198                         asprintf (&output_message,
1199                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1200                                  nss4_name,
1201                                  nss4_value,
1202                                  nss4_name,
1203                                  nss4_value,
1204                                  warning_value,
1205                                  critical_value);
1206                 }
1207
1208         } else if (vars_to_check==NSS5) {
1209
1210                 asprintf (&send_buffer,"NSS5:%s\r\n",nss5_name);
1211                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1212                 if (result!=STATE_OK)
1213                         return result;
1214
1215                 if (!strcmp(recv_buffer,"-1\n")) {
1216                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss5_name);
1217                         result=STATE_CRITICAL;
1218                 }       else {
1219                         nss5_value=strtoul(recv_buffer,NULL,10);
1220                         if (check_critical_value==TRUE && nss5_value >= critical_value)
1221                                 result=STATE_CRITICAL;
1222                         else if (check_warning_value==TRUE && nss5_value >= warning_value)
1223                                 result=STATE_WARNING;
1224                         asprintf (&output_message,
1225                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1226                                  nss5_name,
1227                                  nss5_value,
1228                                  nss5_name,
1229                                  nss5_value,
1230                                  warning_value,
1231                                  critical_value);
1232                 }
1233
1234         } else if (vars_to_check==NSS6) {
1235
1236                 asprintf (&send_buffer,"NSS6:%s\r\n",nss6_name);
1237                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1238                 if (result!=STATE_OK)
1239                         return result;
1240
1241                 if (!strcmp(recv_buffer,"-1\n")) {
1242                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss6_name);
1243                         result=STATE_CRITICAL;
1244                 }       else {
1245                         nss6_value=strtoul(recv_buffer,NULL,10);
1246                         if (check_critical_value==TRUE && nss6_value >= critical_value)
1247                                 result=STATE_CRITICAL;
1248                         else if (check_warning_value==TRUE && nss6_value >= warning_value)
1249                                 result=STATE_WARNING;
1250                         asprintf (&output_message,
1251                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1252                                  nss6_name,
1253                                  nss6_value,
1254                                  nss6_name,
1255                                  nss6_value,
1256                                  warning_value,
1257                                  critical_value);
1258                 }
1259
1260         } else if (vars_to_check==NSS7) {
1261
1262                 asprintf (&send_buffer,"NSS7:%s\r\n",nss7_name);
1263                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1264                 if (result!=STATE_OK)
1265                         return result;
1266
1267                 if (!strcmp(recv_buffer,"-1\n")) {
1268                         asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss7_name);
1269                         result=STATE_CRITICAL;
1270                 }       else {
1271                         nss7_value=strtoul(recv_buffer,NULL,10);
1272                         if (check_critical_value==TRUE && nss7_value >= critical_value)
1273                                 result=STATE_CRITICAL;
1274                         else if (check_warning_value==TRUE && nss7_value >= warning_value)
1275                                 result=STATE_WARNING;
1276                         asprintf (&output_message,
1277                                   _("%s is  %lu|%s=%lu;%lu;%lu;;"),
1278                                  nss7_name,
1279                                  nss7_value,
1280                                  nss7_name,
1281                                  nss7_value,
1282                                  warning_value,
1283                                  critical_value);
1284                 }
1285
1286
1287 }
1288         else {
1289
1290                 output_message = strdup (_("Nothing to check!\n"));
1291                 result=STATE_UNKNOWN;
1292
1293         }
1294
1295         close (sd);
1296
1297         /* reset timeout */
1298         alarm(0);
1299
1300         printf("%s%s\n",netware_version,output_message);
1301
1302         return result;
1303 }
1304
1305
1306
1307 /* process command-line arguments */
1308 int process_arguments(int argc, char **argv) {
1309         int c;
1310
1311         int option = 0;
1312         static struct option longopts[] =
1313                 {
1314                         {"port",     required_argument,0,'p'},
1315                         {"timeout",  required_argument,0,'t'},
1316                         {"critical", required_argument,0,'c'},
1317                         {"warning",  required_argument,0,'w'},
1318                         {"variable", required_argument,0,'v'},
1319                         {"hostname", required_argument,0,'H'},
1320                         {"osversion",no_argument,      0,'o'},
1321                         {"version",  no_argument,      0,'V'},
1322                         {"help",     no_argument,      0,'h'},
1323                         {0,0,0,0}
1324                 };
1325
1326         /* no options were supplied */
1327         if (argc<2) return ERROR;
1328
1329         /* backwards compatibility */
1330         if (! is_option(argv[1])) {
1331                 server_address=argv[1];
1332                 argv[1]=argv[0];
1333                 argv=&argv[1];
1334                 argc--;
1335         }
1336
1337   for (c=1;c<argc;c++) {
1338     if (strcmp("-to",argv[c])==0)
1339       strcpy(argv[c],"-t");
1340     else if (strcmp("-wv",argv[c])==0)
1341       strcpy(argv[c],"-w");
1342     else if (strcmp("-cv",argv[c])==0)
1343       strcpy(argv[c],"-c");
1344         }
1345
1346         while (1) {
1347                 c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",longopts,&option);
1348
1349                 if (c==-1||c==EOF||c==1)
1350                         break;
1351
1352                 switch (c)
1353                         {
1354                         case '?': /* print short usage statement if args not parsable */
1355                         usage5 ();
1356                         case 'h': /* help */
1357                                 print_help();
1358                                 exit(STATE_OK);
1359                         case 'V': /* version */
1360                                 print_revision(progname, revision);
1361                                 exit(STATE_OK);
1362                         case 'H': /* hostname */
1363                                 server_address=optarg;
1364                                 break;
1365                         case 'o': /* display nos version */
1366                                 check_netware_version=TRUE;
1367                                 break;
1368                         case 'p': /* port */
1369                                 if (is_intnonneg(optarg))
1370                                         server_port=atoi(optarg);
1371                                 else
1372                                         die(STATE_UNKNOWN,_("Server port an integer\n"));
1373                                 break;
1374                         case 'v':
1375                                 if (strlen(optarg)<3)
1376                                         return ERROR;
1377                                 if (!strcmp(optarg,"LOAD1"))
1378                                         vars_to_check=LOAD1;
1379                                 else if (!strcmp(optarg,"LOAD5"))
1380                                         vars_to_check=LOAD5;
1381                                 else if (!strcmp(optarg,"LOAD15"))
1382                                         vars_to_check=LOAD15;
1383                                 else if (!strcmp(optarg,"CONNS"))
1384                                         vars_to_check=CONNS;
1385                                 else if (!strcmp(optarg,"LTCH"))
1386                                         vars_to_check=LTCH;
1387                                 else if (!strcmp(optarg,"DCB"))
1388                                         vars_to_check=DCB;
1389                                 else if (!strcmp(optarg,"TCB"))
1390                                         vars_to_check=TCB;
1391                                 else if (!strcmp(optarg,"CBUFF"))
1392                                         vars_to_check=CBUFF;
1393                                 else if (!strcmp(optarg,"CDBUFF"))
1394                                         vars_to_check=CDBUFF;
1395                                 else if (!strcmp(optarg,"LRUM"))
1396                                         vars_to_check=LRUM;
1397                                 else if (!strcmp(optarg,"LRUS"))
1398                                         vars_to_check=LRUS;
1399                                 else if (strncmp(optarg,"VPF",3)==0) {
1400                                         vars_to_check=VPF;
1401                                         volume_name = strdup (optarg+3);
1402                                         if (!strcmp(volume_name,""))
1403                                                 volume_name = strdup ("SYS");
1404                                 }
1405                                 else if (strncmp(optarg,"VKF",3)==0) {
1406                                         vars_to_check=VKF;
1407                                         volume_name = strdup (optarg+3);
1408                                         if (!strcmp(volume_name,""))
1409                                                 volume_name = strdup ("SYS");
1410                                 }
1411                                 else if (strncmp(optarg,"VMF",3)==0) {
1412                                         vars_to_check=VMF;
1413                                         volume_name = strdup (optarg+3);
1414                                         if (!strcmp(volume_name,""))
1415                                                 volume_name = strdup ("SYS");
1416                                 }
1417                                 else if (!strcmp(optarg,"DSDB"))
1418                                         vars_to_check=DSDB;
1419                                 else if (!strcmp(optarg,"LOGINS"))
1420                                         vars_to_check=LOGINS;
1421                                 else if (!strcmp(optarg,"NRMH"))
1422                                         vars_to_check=NRMH;
1423                                 else if (!strcmp(optarg,"UPRB"))
1424                                         vars_to_check=UPRB;
1425                                 else if (!strcmp(optarg,"PUPRB"))
1426                                         vars_to_check=PUPRB;
1427                                 else if (!strncmp(optarg,"SAPENTRIES",10)) {
1428                                         vars_to_check=SAPENTRIES;
1429                                         if (strlen(optarg)>10)
1430                                                 sap_number=atoi(optarg+10);
1431                                         else
1432                                                 sap_number=-1;
1433                                 }
1434                                 else if (!strcmp(optarg,"OFILES"))
1435                                         vars_to_check=OFILES;
1436                                 else if (strncmp(optarg,"VKP",3)==0) {
1437                                         vars_to_check=VKP;
1438                                         volume_name = strdup (optarg+3);
1439                                         if (!strcmp(volume_name,""))
1440                                                 volume_name = strdup ("SYS");
1441                                 }
1442                                 else if (strncmp(optarg,"VMP",3)==0) {
1443                                         vars_to_check=VMP;
1444                                         volume_name = strdup (optarg+3);
1445                                         if (!strcmp(volume_name,""))
1446                                                 volume_name = strdup ("SYS");
1447                                 }
1448                                 else if (strncmp(optarg,"VMU",3)==0) {
1449                                         vars_to_check=VMU;
1450                                         volume_name = strdup (optarg+3);
1451                                         if (!strcmp(volume_name,""))
1452                                                 volume_name = strdup ("SYS");
1453                                 }
1454                                 else if (strncmp(optarg,"VPP",3)==0) {
1455                                         vars_to_check=VPP;
1456                                         volume_name = strdup (optarg+3);
1457                                         if (!strcmp(volume_name,""))
1458                                                 volume_name = strdup ("SYS");
1459                                 }
1460                                 else if (strncmp(optarg,"VKNP",4)==0) {
1461                                         vars_to_check=VKNP;
1462                                         volume_name = strdup (optarg+4);
1463                                         if (!strcmp(volume_name,""))
1464                                                 volume_name = strdup ("SYS");
1465                                 }
1466                                 else if (strncmp(optarg,"VPNP",4)==0) {
1467                                         vars_to_check=VPNP;
1468                                         volume_name = strdup (optarg+4);
1469                                         if (!strcmp(volume_name,""))
1470                                                 volume_name = strdup("SYS");
1471                                 }
1472                                 else if (!strcmp(optarg,"ABENDS"))
1473                                         vars_to_check=ABENDS;
1474                                 else if (!strcmp(optarg,"CSPROCS"))
1475                                         vars_to_check=CSPROCS;
1476                                 else if (!strcmp(optarg,"TSYNC"))
1477                                         vars_to_check=TSYNC;
1478                                 else if (!strcmp(optarg,"DSVER"))
1479                                         vars_to_check=DSVER;
1480                                 else if (!strcmp(optarg,"UPTIME")) {
1481                                         vars_to_check=UPTIME;
1482                                 }
1483                                 else if (strncmp(optarg,"NLM:",4)==0) {
1484                                         vars_to_check=NLM;
1485                                         nlm_name=strdup (optarg+4);
1486                                 }
1487                                 else if (strncmp(optarg,"NRMP",4)==0) {
1488                                         vars_to_check=NRMP;
1489                                         nrmp_name = strdup (optarg+4);
1490                                         if (!strcmp(nrmp_name,""))
1491                                                 nrmp_name = strdup ("AVAILABLE_MEMORY");
1492                                 }
1493                                 else if (strncmp(optarg,"NRMM",4)==0) {
1494                                         vars_to_check=NRMM;
1495                                         nrmm_name = strdup (optarg+4);
1496                                         if (!strcmp(nrmm_name,""))
1497                                                 nrmm_name = strdup ("AVAILABLE_CACHE_MEMORY");
1498
1499                                 }
1500
1501                                 else if (strncmp(optarg,"NRMS",4)==0) {
1502                                         vars_to_check=NRMS;
1503                                         nrms_name = strdup (optarg+4);
1504                                         if (!strcmp(nrms_name,""))
1505                                                 nrms_name = strdup ("USED_SWAP_SPACE");
1506
1507                                 }
1508
1509                                 else if (strncmp(optarg,"NSS1",4)==0) {
1510                                         vars_to_check=NSS1;
1511                                         nss1_name = strdup (optarg+4);
1512                                         if (!strcmp(nss1_name,""))
1513                                                 nss1_name = strdup ("CURRENTBUFFERCACHESIZE");
1514
1515                                 }
1516
1517                                 else if (strncmp(optarg,"NSS2",4)==0) {
1518                                         vars_to_check=NSS2;
1519                                         nss2_name = strdup (optarg+4);
1520                                         if (!strcmp(nss2_name,""))
1521                                                 nss2_name = strdup ("CACHEHITS");
1522
1523                                 }
1524
1525                                 else if (strncmp(optarg,"NSS3",4)==0) {
1526                                         vars_to_check=NSS3;
1527                                         nss3_name = strdup (optarg+4);
1528                                         if (!strcmp(nss3_name,""))
1529                                                 nss3_name = strdup ("CACHEGITPERCENT");
1530
1531                                 }
1532
1533                                 else if (strncmp(optarg,"NSS4",4)==0) {
1534                                         vars_to_check=NSS4;
1535                                         nss4_name = strdup (optarg+4);
1536                                         if (!strcmp(nss4_name,""))
1537                                                 nss4_name = strdup ("CURRENTOPENCOUNT");
1538
1539                                 }
1540
1541                                 else if (strncmp(optarg,"NSS5",4)==0) {
1542                                         vars_to_check=NSS5;
1543                                         nss5_name = strdup (optarg+4);
1544                                         if (!strcmp(nss5_name,""))
1545                                                 nss5_name = strdup ("CACHEMISSES");
1546
1547                                 }
1548
1549
1550                                 else if (strncmp(optarg,"NSS6",4)==0) {
1551                                         vars_to_check=NSS6;
1552                                         nss6_name = strdup (optarg+4);
1553                                         if (!strcmp(nss6_name,""))
1554                                                 nss6_name = strdup ("PENDINGWORKSCOUNT");
1555
1556                                 }
1557
1558
1559                                 else if (strncmp(optarg,"NSS7",4)==0) {
1560                                         vars_to_check=NSS7;
1561                                         nss7_name = strdup (optarg+4);
1562                                         if (!strcmp(nss7_name,""))
1563                                                 nss7_name = strdup ("CACHESIZE");
1564
1565                                 }
1566
1567
1568                                 else
1569                                         return ERROR;
1570                                 break;
1571                         case 'w': /* warning threshold */
1572                                 warning_value=strtoul(optarg,NULL,10);
1573                                 check_warning_value=TRUE;
1574                                 break;
1575                         case 'c': /* critical threshold */
1576                                 critical_value=strtoul(optarg,NULL,10);
1577                                 check_critical_value=TRUE;
1578                                 break;
1579                         case 't': /* timeout */
1580                                 socket_timeout=atoi(optarg);
1581                                 if (socket_timeout<=0)
1582                                         return ERROR;
1583                         }
1584
1585         }
1586
1587         return OK;
1588 }
1589
1590
1591
1592 void print_help(void)
1593 {
1594         char *myport;
1595         asprintf (&myport, "%d", PORT);
1596
1597         print_revision (progname, revision);
1598
1599         printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
1600         printf (COPYRIGHT, copyright, email);
1601
1602         printf ("%s\n", _("This plugin attempts to contact the MRTGEXT NLM running on a"));
1603   printf ("%s\n", _("Novell server to gather the requested system information."));
1604
1605   printf ("\n\n");
1606
1607         print_usage();
1608
1609         printf (_(UT_HELP_VRSN));
1610
1611         printf (_(UT_HOST_PORT), 'p', myport);
1612
1613         printf (" %s\n", "-v, --variable=STRING");
1614   printf ("   %s\n", _("Variable to check.  Valid variables include:"));
1615   printf ("    %s\n", _("LOAD1     = 1 minute average CPU load"));
1616   printf ("    %s\n", _("LOAD5     = 5 minute average CPU load"));
1617   printf ("    %s\n", _("LOAD15    = 15 minute average CPU load"));
1618   printf ("    %s\n", _("CSPROCS   = number of current service processes (NW 5.x only)"));
1619   printf ("    %s\n", _("ABENDS    = number of abended threads (NW 5.x only)"));
1620   printf ("    %s\n", _("UPTIME    = server uptime"));
1621         printf ("    %s\n", _("LTCH      = percent long term cache hits"));
1622   printf ("    %s\n", _("CBUFF     = current number of cache buffers"));
1623   printf ("    %s\n", _("CDBUFF    = current number of dirty cache buffers"));
1624   printf ("    %s\n", _("DCB       = dirty cache buffers as a percentage of the total"));
1625   printf ("    %s\n", _("TCB       = dirty cache buffers as a percentage of the original"));
1626         printf ("    %s\n", _("OFILES    = number of open files"));
1627   printf ("    %s\n", _("    VMF<vol>  = MB of free space on Volume <vol>"));
1628   printf ("    %s\n", _("    VMU<vol>  = MB used space on Volume <vol>"));
1629   printf ("    %s\n", _("    VMP<vol>  = MB of purgeable space on Volume <vol>"));
1630   printf ("    %s\n", _("    VPF<vol>  = percent free space on volume <vol>"));
1631   printf ("    %s\n", _("    VKF<vol>  = KB of free space on volume <vol>"));
1632   printf ("    %s\n", _("    VPP<vol>  = percent purgeable space on volume <vol>"));
1633   printf ("    %s\n", _("    VKP<vol>  = KB of purgeable space on volume <vol>"));
1634   printf ("    %s\n", _("    VPNP<vol> = percent not yet purgeable space on volume <vol>"));
1635   printf ("    %s\n", _("    VKNP<vol> = KB of not yet purgeable space on volume <vol>"));
1636   printf ("    %s\n", _("    LRUM      = LRU sitting time in minutes"));
1637   printf ("    %s\n", _("    LRUS      = LRU sitting time in seconds"));
1638   printf ("    %s\n", _("    DSDB      = check to see if DS Database is open"));
1639   printf ("    %s\n", _("    DSVER     = NDS version"));
1640   printf ("    %s\n", _("    UPRB      = used packet receive buffers"));
1641   printf ("    %s\n", _("    PUPRB     = percent (of max) used packet receive buffers"));
1642   printf ("    %s\n", _("    SAPENTRIES = number of entries in the SAP table"));
1643   printf ("    %s\n", _("    SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>"));
1644   printf ("    %s\n", _("    TSYNC     = timesync status"));
1645   printf ("    %s\n", _("    LOGINS    = check to see if logins are enabled"));
1646   printf ("    %s\n", _("    CONNS     = number of currently licensed connections"));
1647   printf ("    %s\n", _("    NRMH       = NRM Summary Status"));
1648   printf ("    %s\n", _("    NRMP<stat> = Returns the current value for a NRM health item"));
1649   printf ("    %s\n", _("    NRMM<stat> = Returns the current memory stats from NRM"));
1650   printf ("    %s\n", _("    NRMS<stat> = Returns the current Swapfile stats from NRM"));
1651   printf ("    %s\n", _("    NSS1<stat> = Statistics from _Admin:Manage_NSS\\GeneralStats.xml"));
1652   printf ("    %s\n", _("    NSS3<stat> = Statistics from _Admin:Manage_NSS\\NameCache.xml"));
1653   printf ("    %s\n", _("    NSS4<stat> = Statistics from _Admin:Manage_NSS\\FileStats.xml"));
1654   printf ("    %s\n", _("    NSS5<stat> = Statistics from _Admin:Manage_NSS\\ObjectCache.xml"));
1655   printf ("    %s\n", _("    NSS6<stat> = Statistics from _Admin:Manage_NSS\\Thread.xml"));
1656   printf ("    %s\n", _("    NSS7<stat> = Statistics from _Admin:Manage_NSS\\AuthorizationCache.xml"));
1657   printf ("    %s\n", _("    NLM:<nlm> = check if NLM is loaded and report version"));
1658   printf ("    %s\n", _("                (e.g. NLM:TSANDS.NLM)"));
1659   printf ("\n");
1660         printf (" %s\n", "-w, --warning=INTEGER");
1661   printf ("    %s\n", _("Threshold which will result in a warning status"));
1662   printf (" %s\n", "-c, --critical=INTEGER");
1663   printf ("    %s\n", _("Threshold which will result in a critical status"));
1664   printf (" %s\n", "-o, --osversion");
1665   printf ("    %s\n", _("Include server version string in results"));
1666
1667         printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
1668
1669   printf ("\n");
1670   printf ("%s\n", _("Notes:"));
1671         printf (" %s\n", _("- This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG"));
1672   printf (" %s\n", _("  extension for NetWare be loaded on the Novell servers you wish to check."));
1673   printf (" %s\n", _("  (available from http://www.engr.wisc.edu/~drews/mrtg/)"));
1674   printf (" %s\n", _("- Values for critical thresholds should be lower than warning thresholds"));
1675   printf (" %s\n", _("  when the following variables are checked: VPF, VKF, LTCH, CBUFF, DCB, "));
1676   printf (" %s\n", _("  TCB, LRUS and LRUM.\n"));
1677
1678         printf (_(UT_SUPPORT));
1679 }
1680
1681
1682
1683 void print_usage(void)
1684 {
1685   printf (_("Usage:"));
1686         printf ("%s -H host [-p port] [-v variable] [-w warning] [-c critical] [-t timeout]\n",progname);
1687 }