plugins/check_nwstat.c

   1 /******************************************************************************
   2  *
   3  * Program: NetWare statistics plugin for Nagios
   4  * License: GPL
   5  *
   6  * License Information:
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  * $Id$
  23  *
  24  *****************************************************************************/
  25
  26 const char *progname = "check_nwstat";
  27 #define REVISION "$Revision$"
  28 #define COPYRIGHT "Copyright (c) 1999-2001 Ethan Galstad"
  29
  30 #define SUMMARY "\
  31 This plugin attempts to contact the MRTGEXT NLM running on a Novell server\n\
  32 to gather the requested system information.\n"
  33
  34 #define OPTIONS "\
  35 -H host [-v variable] [-w warning] [-c critical]\n\
  36               [-p port] [-t timeout]"
  37
  38 #define LONGOPTIONS "\
  39 -H, --hostname=HOST\n\
  40   Name of the host to check\n\
  41 -v, --variable=STRING\n\
  42   Variable to check.  Valid variables include:\n\
  43      LOAD1    = 1 minute average CPU load\n\
  44      LOAD5    = 5 minute average CPU load\n\
  45      LOAD15   = 15 minute average CPU load\n\
  46      CONNS    = number of currently licensed connections\n\
  47      VPF<vol> = percent free space on volume <vol>\n\
  48      VKF<vol> = KB of free space on volume <vol>\n\
  49      LTCH     = percent long term cache hits\n\
  50      CBUFF    = current number of cache buffers\n\
  51      CDBUFF   = current number of dirty cache buffers\n\
  52      LRUM     = LRU sitting time in minutes\n\
  53      DSDB     = check to see if DS Database is open\n\
  54      LOGINS   = check to see if logins are enabled\n\
  55      UPRB     = used packet receive buffers\n\
  56      PUPRB    = percent (of max) used packet receive buffers\n\
  57      SAPENTRIES = number of entries in the SAP table\n\
  58      SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>\n\
  59      OFILES   = number of open files\n\
  60      VPP<vol> = percent purgeable space on volume <vol>\n\
  61      VKP<vol> = KB of purgeable space on volume <vol>\n\
  62      VPNP<vol> = percent not yet purgeable space on volume <vol>\n\
  63      VKNP<vol> = KB of not yet purgeable space on volume <vol>\n\
  64      ABENDS   = number of abended threads (NW 5.x only)\n\
  65      CSPROCS  = number of current service processes (NW 5.x only)\n\
  66 -w, --warning=INTEGER\n\
  67   Threshold which will result in a warning status\n\
  68 -c, --critical=INTEGER\n\
  69   Threshold which will result in a critical status\n\
  70 -p, --port=INTEGER\n\
  71   Optional port number (default: %d)\n\
  72 -t, --timeout=INTEGER\n\
  73   Seconds before connection attempt times out (default: %d)\n\
  74 -o, --osversion\n\
  75   Include server version string in results\n\
  76 -h, --help\n\
  77   Print this help screen\n\
  78 -V, --version\n\
  79   Print version information\n"
  80
  81 #define DESCRIPTION "\
  82 Notes:\n\
  83 - This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG\n\
  84   extension for NetWare be loaded on the Novell servers you wish to check.\n\
  85   (available from http://www.engr.wisc.edu/~drews/mrtg/)\n\
  86 - Values for critical thresholds should be lower than warning thresholds\n\
  87   when the following variables are checked: VPF, VKF, LTCH, CBUFF, and LRUM.\n"
  88
  89 #include "config.h"
  90 #include "common.h"
  91 #include "netutils.h"
  92 #include "utils.h"
  93
  94 #define CHECK_NONE           0
  95 #define CHECK_LOAD1          1 /* check 1 minute CPU load */
  96 #define CHECK_LOAD5          2 /* check 5 minute CPU load */
  97 #define CHECK_LOAD15         3 /* check 15 minute CPU load */
  98 #define CHECK_CONNS          4 /* check number of connections */
  99 #define CHECK_VPF            5 /* check % free space on volume */
 100 #define CHECK_VKF            6 /* check KB free space on volume */
 101 #define CHECK_LTCH           7 /* check long-term cache hit percentage */
 102 #define CHECK_CBUFF          8 /* check total cache buffers */
 103 #define CHECK_CDBUFF         9 /* check dirty cache buffers */
 104 #define CHECK_LRUM          10 /* check LRU sitting time in minutes */
 105 #define CHECK_DSDB          11 /* check to see if DS Database is open */
 106 #define CHECK_LOGINS        12 /* check to see if logins are enabled */
 107 #define CHECK_PUPRB         13 /* check % of used packet receive buffers */
 108 #define CHECK_UPRB          14 /* check used packet receive buffers */
 109 #define CHECK_SAPENTRIES    15 /* check SAP entries */
 110 #define CHECK_OFILES        16 /* check number of open files */
 111 #define CHECK_VKP           17 /* check KB purgeable space on volume */
 112 #define CHECK_VPP           18 /* check % purgeable space on volume */
 113 #define CHECK_VKNP          19 /* check KB not yet purgeable space on volume */
 114 #define CHECK_VPNP          20 /* check % not yet purgeable space on volume */
 115 #define CHECK_ABENDS        21 /* check abended thread count */
 116 #define CHECK_CSPROCS       22 /* check number of current service processes */
 117
 118 #define PORT 9999
 119
 120 char *server_address=NULL;
 121 char *volume_name=NULL;
 122 int server_port=PORT;
 123 unsigned long warning_value=0L;
 124 unsigned long critical_value=0L;
 125 int check_warning_value=FALSE;
 126 int check_critical_value=FALSE;
 127 int check_netware_version=FALSE;
 128 unsigned long vars_to_check=CHECK_NONE;
 129 int sap_number=-1;
 130
 131 int process_arguments(int, char **);
 132 void print_usage(void);
 133 void print_help(void);
 134
 135 int main(int argc, char **argv){
 136         int result;
 137         char *send_buffer=NULL;
 138         char recv_buffer[MAX_INPUT_BUFFER];
 139         char *output_message=NULL;
 140         char *temp_buffer=NULL;
 141         char *netware_version=NULL;
 142
 143         int open_files=0;
 144         int abended_threads=0;
 145         int max_service_processes=0;
 146         int current_service_processes=0;
 147         unsigned long free_disk_space=0L;
 148         unsigned long total_disk_space=0L;
 149         unsigned long purgeable_disk_space=0L;
 150         unsigned long non_purgeable_disk_space=0L;
 151         int percent_free_space=0;
 152         int percent_purgeable_space=0;
 153         int percent_non_purgeable_space=0;
 154         unsigned long current_connections=0L;
 155         unsigned long utilization=0L;
 156         int cache_hits=0;
 157         unsigned long cache_buffers=0L;
 158         unsigned long lru_time=0L;
 159         char uptime[MAX_INPUT_BUFFER];
 160         int max_packet_receive_buffers=0;
 161         int used_packet_receive_buffers=0;
 162         unsigned long percent_used_packet_receive_buffers=0L;
 163         int sap_entries=0;
 164
 165         if(process_arguments(argc,argv)==ERROR)
 166                 usage("Could not parse arguments\n");
 167
 168         /* initialize alarm signal handling */
 169         signal(SIGALRM,socket_timeout_alarm_handler);
 170
 171         /* set socket timeout */
 172         alarm(socket_timeout);
 173
 174         /* get OS version string */
 175         if (check_netware_version==TRUE) {
 176                 send_buffer = strscpy(send_buffer,"S19\r\n");
 177                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 178                 if(result!=STATE_OK)
 179                         return result;
 180                 if(!strcmp(recv_buffer,"-1\n"))
 181                         asprintf(&netware_version,"");
 182                 else {
 183                         recv_buffer[strlen(recv_buffer)-1]=0;
 184                         asprintf(&netware_version,"NetWare %s: ",recv_buffer);
 185                 }
 186         } else
 187                 asprintf(&netware_version,"");
 188
 189
 190         /* check CPU load */
 191         if (vars_to_check==CHECK_LOAD1 || vars_to_check==CHECK_LOAD5 || vars_to_check==CHECK_LOAD15) {
 192
 193                 switch(vars_to_check){
 194                 case CHECK_LOAD1:
 195                         temp_buffer = strscpy(temp_buffer,"1");
 196                         break;
 197                 case CHECK_LOAD5:
 198                         temp_buffer = strscpy(temp_buffer,"5");
 199                         break;
 200                 default:
 201                         temp_buffer = strscpy(temp_buffer,"15");
 202                         break;
 203                 }
 204
 205                 asprintf(&send_buffer,"UTIL%s\r\n",temp_buffer);
 206                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 207                 if(result!=STATE_OK)
 208                         return result;
 209                 utilization=strtoul(recv_buffer,NULL,10);
 210                 send_buffer = strscpy(send_buffer,"UPTIME\r\n");
 211                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 212                 if(result!=STATE_OK)
 213                         return result;
 214                 recv_buffer[strlen(recv_buffer)-1]=0;
 215                 sprintf(uptime,"Up %s,",recv_buffer);
 216
 217                 if(check_critical_value==TRUE && utilization >= critical_value)
 218                         result=STATE_CRITICAL;
 219                 else if(check_warning_value==TRUE && utilization >= warning_value)
 220                         result=STATE_WARNING;
 221
 222                 asprintf(&output_message,"Load %s - %s %s-min load average = %lu%%",(result==STATE_OK)?"ok":"problem",uptime,temp_buffer,utilization);
 223
 224         /* check number of user connections */
 225         } else if (vars_to_check==CHECK_CONNS) {
 226
 227                 send_buffer = strscpy(send_buffer,"CONNECT\r\n");
 228                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 229                 if(result!=STATE_OK)
 230                         return result;
 231                 current_connections=strtoul(recv_buffer,NULL,10);
 232
 233                 if(check_critical_value==TRUE && current_connections >= critical_value)
 234                         result=STATE_CRITICAL;
 235                 else if(check_warning_value==TRUE && current_connections >= warning_value)
 236                         result=STATE_WARNING;
 237                 asprintf(&output_message,"Conns %s - %lu current connections",(result==STATE_OK)?"ok":"problem",current_connections);
 238
 239         /* check % long term cache hits */
 240         } else if (vars_to_check==CHECK_LTCH) {
 241
 242                 send_buffer = strscpy(send_buffer,"S1\r\n");
 243                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 244                 if(result!=STATE_OK)
 245                         return result;
 246                 cache_hits=atoi(recv_buffer);
 247
 248                 if(check_critical_value==TRUE && cache_hits <= critical_value)
 249                         result=STATE_CRITICAL;
 250                 else if(check_warning_value==TRUE && cache_hits <= warning_value)
 251                         result=STATE_WARNING;
 252                 asprintf(&output_message,"Long term cache hits = %d%%",cache_hits);
 253
 254         /* check cache buffers */
 255         } else if (vars_to_check==CHECK_CBUFF) {
 256
 257                 send_buffer = strscpy(send_buffer,"S2\r\n");
 258                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 259                 if(result!=STATE_OK)
 260                         return result;
 261                 cache_buffers=strtoul(recv_buffer,NULL,10);
 262
 263                 if(check_critical_value==TRUE && cache_buffers <= critical_value)
 264                         result=STATE_CRITICAL;
 265                 else if(check_warning_value==TRUE && cache_buffers <= warning_value)
 266                         result=STATE_WARNING;
 267                 asprintf(&output_message,"Total cache buffers = %lu",cache_buffers);
 268
 269         /* check dirty cache buffers */
 270         } else if (vars_to_check==CHECK_CDBUFF) {
 271
 272                 send_buffer = strscpy(send_buffer,"S3\r\n");
 273                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 274                 if(result!=STATE_OK)
 275                         return result;
 276                 cache_buffers=strtoul(recv_buffer,NULL,10);
 277
 278                 if(check_critical_value==TRUE && cache_buffers >= critical_value)
 279                         result=STATE_CRITICAL;
 280                 else if(check_warning_value==TRUE && cache_buffers >= warning_value)
 281                         result=STATE_WARNING;
 282                 asprintf(&output_message,"Dirty cache buffers = %lu",cache_buffers);
 283
 284         /* check LRU sitting time in minutes */
 285         } else if (vars_to_check==CHECK_LRUM) {
 286
 287                 send_buffer = strscpy(send_buffer,"S5\r\n");
 288                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 289                 if(result!=STATE_OK)
 290                         return result;
 291                 lru_time=strtoul(recv_buffer,NULL,10);
 292
 293                 if(check_critical_value==TRUE && lru_time <= critical_value)
 294                         result=STATE_CRITICAL;
 295                 else if(check_warning_value==TRUE && lru_time <= warning_value)
 296                         result=STATE_WARNING;
 297                 asprintf(&output_message,"LRU sitting time = %lu minutes",lru_time);
 298
 299
 300         /* check KB free space on volume */
 301         } else if (vars_to_check==CHECK_VKF) {
 302
 303                 asprintf(&send_buffer,"VKF%s\r\n",volume_name);
 304                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 305                 if(result!=STATE_OK)
 306                         return result;
 307
 308                 if (!strcmp(recv_buffer,"-1\n")) {
 309                         asprintf(&output_message,"Error: Volume '%s' does not exist!",volume_name);
 310                         result=STATE_CRITICAL;
 311                 }       else {
 312                         free_disk_space=strtoul(recv_buffer,NULL,10);
 313                         if(check_critical_value==TRUE && free_disk_space <= critical_value)
 314                                 result=STATE_CRITICAL;
 315                         else if(check_warning_value==TRUE && free_disk_space <= warning_value)
 316                                 result=STATE_WARNING;
 317                         asprintf(&output_message,"%s%lu KB free on volume %s",(result==STATE_OK)?"":"Only ",free_disk_space,volume_name);
 318                 }
 319
 320         /* check % free space on volume */
 321         } else if (vars_to_check==CHECK_VPF) {
 322
 323                 asprintf(&send_buffer,"VKF%s\r\n",volume_name);
 324                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 325                 if(result!=STATE_OK)
 326                         return result;
 327
 328                 if(!strcmp(recv_buffer,"-1\n")){
 329
 330                         asprintf(&output_message,"Error: Volume '%s' does not exist!",volume_name);
 331                         result=STATE_CRITICAL;
 332
 333                 } else {
 334
 335                         free_disk_space=strtoul(recv_buffer,NULL,10);
 336
 337                         asprintf(&send_buffer,"VKS%s\r\n",volume_name);
 338                         result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 339                         if(result!=STATE_OK)
 340                                 return result;
 341                         total_disk_space=strtoul(recv_buffer,NULL,10);
 342
 343                         percent_free_space=(int)(((double)free_disk_space/(double)total_disk_space)*100.0);
 344
 345                         if(check_critical_value==TRUE && percent_free_space <= critical_value)
 346                                 result=STATE_CRITICAL;
 347                         else if(check_warning_value==TRUE && percent_free_space <= warning_value)
 348                                 result=STATE_WARNING;
 349                         free_disk_space/=1024;
 350                         asprintf(&output_message,"%lu MB (%d%%) free on volume %s",free_disk_space,percent_free_space,volume_name);
 351                 }
 352
 353         /* check to see if DS Database is open or closed */
 354         } else if(vars_to_check==CHECK_DSDB) {
 355
 356                 send_buffer = strscpy(send_buffer,"S11\r\n");
 357                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 358                 if(result!=STATE_OK)
 359                         return result;
 360                 if(atoi(recv_buffer)==1)
 361                         result=STATE_OK;
 362                 else
 363                         result=STATE_WARNING;
 364
 365                 send_buffer = strscpy(send_buffer,"S13\r\n");
 366                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 367                 temp_buffer=strtok(recv_buffer,"\r\n");
 368
 369                 asprintf(&output_message,"Directory Services Database is %s (DS version %s)",(result==STATE_OK)?"open":"closed",temp_buffer);
 370
 371         /* check to see if logins are enabled */
 372         } else if (vars_to_check==CHECK_LOGINS) {
 373
 374                 send_buffer = strscpy(send_buffer,"S12\r\n");
 375                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 376                 if(result!=STATE_OK)
 377                         return result;
 378                 if(atoi(recv_buffer)==1)
 379                         result=STATE_OK;
 380                 else
 381                         result=STATE_WARNING;
 382
 383                 asprintf(&output_message,"Logins are %s",(result==STATE_OK)?"enabled":"disabled");
 384
 385         /* check packet receive buffers */
 386         } else if (vars_to_check==CHECK_UPRB || vars_to_check==CHECK_PUPRB) {
 387
 388                 asprintf(&send_buffer,"S15\r\n",volume_name);
 389                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 390                 if(result!=STATE_OK)
 391                         return result;
 392
 393                 used_packet_receive_buffers=atoi(recv_buffer);
 394
 395                 asprintf(&send_buffer,"S16\r\n",volume_name);
 396                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 397                 if(result!=STATE_OK)
 398                         return result;
 399
 400                 max_packet_receive_buffers=atoi(recv_buffer);
 401
 402                 percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
 403
 404                 if(vars_to_check==CHECK_UPRB){
 405                         if(check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
 406                                 result=STATE_CRITICAL;
 407                         else if(check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
 408                                 result=STATE_WARNING;
 409                 } else {
 410                         if(check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
 411                                 result=STATE_CRITICAL;
 412                         else if(check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
 413                                 result=STATE_WARNING;
 414                 }
 415
 416                 asprintf(&output_message,"%d of %d (%lu%%) packet receive buffers used",used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
 417
 418         /* check SAP table entries */
 419         } else if (vars_to_check==CHECK_SAPENTRIES) {
 420
 421                 if(sap_number==-1)
 422                         asprintf(&send_buffer,"S9\r\n");
 423                 else
 424                         asprintf(&send_buffer,"S9.%d\r\n",sap_number);
 425                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 426                 if(result!=STATE_OK)
 427                         return result;
 428
 429                 sap_entries=atoi(recv_buffer);
 430
 431                 if(check_critical_value==TRUE && sap_entries >= critical_value)
 432                         result=STATE_CRITICAL;
 433                 else if(check_warning_value==TRUE && sap_entries >= warning_value)
 434                         result=STATE_WARNING;
 435
 436                 if(sap_number==-1)
 437                         asprintf(&output_message,"%d entries in SAP table",sap_entries);
 438                 else
 439                         asprintf(&output_message,"%d entries in SAP table for SAP type %d",sap_entries,sap_number);
 440
 441         /* check KB purgeable space on volume */
 442         } else if (vars_to_check==CHECK_VKP) {
 443
 444                 asprintf(&send_buffer,"VKP%s\r\n",volume_name);
 445                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 446                 if(result!=STATE_OK)
 447                         return result;
 448
 449                 if (!strcmp(recv_buffer,"-1\n")) {
 450                         asprintf(&output_message,"Error: Volume '%s' does not exist!",volume_name);
 451                         result=STATE_CRITICAL;
 452                 } else {
 453                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 454                         if(check_critical_value==TRUE && purgeable_disk_space >= critical_value)
 455                                 result=STATE_CRITICAL;
 456                         else if(check_warning_value==TRUE && purgeable_disk_space >= warning_value)
 457                                 result=STATE_WARNING;
 458                         asprintf(&output_message,"%s%lu KB purgeable on volume %s",(result==STATE_OK)?"":"Only ",purgeable_disk_space,volume_name);
 459                 }
 460
 461         /* check % purgeable space on volume */
 462         } else if (vars_to_check==CHECK_VPP) {
 463
 464                 asprintf(&send_buffer,"VKP%s\r\n",volume_name);
 465                 result=process_tcp_request(server_address,server_port,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,"Error: Volume '%s' does not exist!",volume_name);
 472                         result=STATE_CRITICAL;
 473
 474                 } else {
 475
 476                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 477
 478                         asprintf(&send_buffer,"VKS%s\r\n",volume_name);
 479                         result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 480                         if(result!=STATE_OK)
 481                                 return result;
 482                         total_disk_space=strtoul(recv_buffer,NULL,10);
 483
 484                         percent_purgeable_space=(int)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
 485
 486                         if(check_critical_value==TRUE && percent_purgeable_space >= critical_value)
 487                                 result=STATE_CRITICAL;
 488                         else if(check_warning_value==TRUE && percent_purgeable_space >= warning_value)
 489                                 result=STATE_WARNING;
 490                         purgeable_disk_space/=1024;
 491                         asprintf(&output_message,"%lu MB (%d%%) purgeable on volume %s",purgeable_disk_space,percent_purgeable_space,volume_name);
 492                 }
 493
 494         /* check KB not yet purgeable space on volume */
 495         } else if (vars_to_check==CHECK_VKNP) {
 496
 497                 asprintf(&send_buffer,"VKNP%s\r\n",volume_name);
 498                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 499                 if(result!=STATE_OK)
 500                         return result;
 501
 502                 if (!strcmp(recv_buffer,"-1\n")) {
 503                         asprintf(&output_message,"Error: Volume '%s' does not exist!",volume_name);
 504                         result=STATE_CRITICAL;
 505                 } else {
 506                         non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 507                         if(check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
 508                                 result=STATE_CRITICAL;
 509                         else if(check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
 510                                 result=STATE_WARNING;
 511                         asprintf(&output_message,"%s%lu KB not yet purgeable on volume %s",(result==STATE_OK)?"":"Only ",non_purgeable_disk_space,volume_name);
 512                 }
 513
 514         /* check % not yet purgeable space on volume */
 515         } else if (vars_to_check==CHECK_VPNP) {
 516
 517                 asprintf(&send_buffer,"VKNP%s\r\n",volume_name);
 518                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 519                 if(result!=STATE_OK)
 520                         return result;
 521
 522                 if(!strcmp(recv_buffer,"-1\n")){
 523
 524                         asprintf(&output_message,"Error: Volume '%s' does not exist!",volume_name);
 525                         result=STATE_CRITICAL;
 526
 527                 } else {
 528
 529                         non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 530
 531                         asprintf(&send_buffer,"VKS%s\r\n",volume_name);
 532                         result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 533                         if(result!=STATE_OK)
 534                                 return result;
 535                         total_disk_space=strtoul(recv_buffer,NULL,10);
 536
 537                         percent_non_purgeable_space=(int)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
 538
 539                         if(check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
 540                                 result=STATE_CRITICAL;
 541                         else if(check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
 542                                 result=STATE_WARNING;
 543                         purgeable_disk_space/=1024;
 544                         asprintf(&output_message,"%lu MB (%d%%) not yet purgeable on volume %s",non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
 545                 }
 546
 547         /* check # of open files */
 548         } else if (vars_to_check==CHECK_OFILES) {
 549
 550                 asprintf(&send_buffer,"S18\r\n");
 551                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 552                 if(result!=STATE_OK)
 553                         return result;
 554
 555                 open_files=atoi(recv_buffer);
 556
 557                 if(check_critical_value==TRUE && open_files >= critical_value)
 558                         result=STATE_CRITICAL;
 559                 else if(check_warning_value==TRUE && open_files >= warning_value)
 560                         result=STATE_WARNING;
 561
 562                 asprintf(&output_message,"%d open files",open_files);
 563
 564         /* check # of abended threads (Netware 5.x only) */
 565         } else if (vars_to_check==CHECK_ABENDS) {
 566
 567                 asprintf(&send_buffer,"S17\r\n");
 568                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 569                 if(result!=STATE_OK)
 570                         return result;
 571
 572                 abended_threads=atoi(recv_buffer);
 573
 574                 if(check_critical_value==TRUE && abended_threads >= critical_value)
 575                         result=STATE_CRITICAL;
 576                 else if(check_warning_value==TRUE && abended_threads >= warning_value)
 577                         result=STATE_WARNING;
 578
 579                 asprintf(&output_message,"%d abended threads",abended_threads);
 580
 581         /* check # of current service processes (Netware 5.x only) */
 582         } else if (vars_to_check==CHECK_CSPROCS) {
 583
 584                 asprintf(&send_buffer,"S20\r\n");
 585                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 586                 if(result!=STATE_OK)
 587                         return result;
 588
 589                 max_service_processes=atoi(recv_buffer);
 590
 591                 asprintf(&send_buffer,"S21\r\n");
 592                 result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
 593                 if(result!=STATE_OK)
 594                         return result;
 595
 596                 current_service_processes=atoi(recv_buffer);
 597
 598                 if(check_critical_value==TRUE && current_service_processes >= critical_value)
 599                         result=STATE_CRITICAL;
 600                 else if(check_warning_value==TRUE && current_service_processes >= warning_value)
 601                         result=STATE_WARNING;
 602
 603                 asprintf(&output_message,"%d current service processes (%d max)",current_service_processes,max_service_processes);
 604
 605         } else {
 606
 607                 output_message = strscpy(output_message,"Nothing to check!\n");
 608                 result=STATE_UNKNOWN;
 609
 610         }
 611
 612         /* reset timeout */
 613         alarm(0);
 614
 615         printf("%s%s\n",netware_version,output_message);
 616
 617         return result;
 618 }
 619
 620
 621 /* process command-line arguments */
 622 int process_arguments(int argc, char **argv){
 623         int c;
 624
 625         int option_index = 0;
 626         static struct option long_options[] =
 627         {
 628                 {"port",     required_argument,0,'p'},
 629                 {"timeout",  required_argument,0,'t'},
 630                 {"critical", required_argument,0,'c'},
 631                 {"warning",  required_argument,0,'w'},
 632                 {"variable", required_argument,0,'v'},
 633                 {"hostname", required_argument,0,'H'},
 634                 {"osversion",no_argument,      0,'o'},
 635                 {"version",  no_argument,      0,'V'},
 636                 {"help",     no_argument,      0,'h'},
 637                 {0,0,0,0}
 638         };
 639
 640         /* no options were supplied */
 641         if(argc<2) return ERROR;
 642
 643         /* backwards compatibility */
 644         if (! is_option(argv[1])) {
 645                 server_address=argv[1];
 646                 argv[1]=argv[0];
 647                 argv=&argv[1];
 648                 argc--;
 649         }
 650
 651   for (c=1;c<argc;c++) {
 652     if(strcmp("-to",argv[c])==0)
 653       strcpy(argv[c],"-t");
 654     else if (strcmp("-wv",argv[c])==0)
 655       strcpy(argv[c],"-w");
 656     else if (strcmp("-cv",argv[c])==0)
 657       strcpy(argv[c],"-c");
 658         }
 659
 660         while (1){
 661                 c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",long_options,&option_index);
 662
 663                 if (c==-1||c==EOF||c==1)
 664                         break;
 665
 666                 switch (c)
 667                         {
 668                         case '?': /* print short usage statement if args not parsable */
 669                                 printf ("%s: Unknown argument: %s\n\n", progname, optarg);
 670                                 print_usage();
 671                                 exit(STATE_UNKNOWN);
 672                         case 'h': /* help */
 673                                 print_help();
 674                                 exit(STATE_OK);
 675                         case 'V': /* version */
 676                                 print_revision(progname,"$Revision$");
 677                                 exit(STATE_OK);
 678                         case 'H': /* hostname */
 679                                 server_address=optarg;
 680                                 break;
 681                         case 'o': /* display nos version */
 682                                 check_netware_version=TRUE;
 683                                 break;
 684                         case 'p': /* port */
 685                                 if (is_intnonneg(optarg))
 686                                         server_port=atoi(optarg);
 687                                 else
 688                                         terminate(STATE_UNKNOWN,"Server port an integer (seconds)\nType '%s -h' for additional help\n",progname);
 689                                 break;
 690                         case 'v':
 691                                 if(strlen(optarg)<3)
 692                                         return ERROR;
 693                                 if(!strcmp(optarg,"LOAD1"))
 694                                         vars_to_check=CHECK_LOAD1;
 695                                 else if(!strcmp(optarg,"LOAD5"))
 696                                         vars_to_check=CHECK_LOAD5;
 697                                 else if(!strcmp(optarg,"LOAD15"))
 698                                         vars_to_check=CHECK_LOAD15;
 699                                 else if(!strcmp(optarg,"CONNS"))
 700                                         vars_to_check=CHECK_CONNS;
 701                                 else if(!strcmp(optarg,"LTCH"))
 702                                         vars_to_check=CHECK_LTCH;
 703                                 else if(!strcmp(optarg,"CBUFF"))
 704                                         vars_to_check=CHECK_CBUFF;
 705                                 else if(!strcmp(optarg,"CDBUFF"))
 706                                         vars_to_check=CHECK_CDBUFF;
 707                                 else if(!strcmp(optarg,"LRUM"))
 708                                         vars_to_check=CHECK_LRUM;
 709                                 else if(strncmp(optarg,"VPF",3)==0){
 710                                         vars_to_check=CHECK_VPF;
 711                                         volume_name = strscpy(volume_name,optarg+3);
 712                                         if(!strcmp(volume_name,""))
 713                                                 volume_name = strscpy(volume_name,"SYS");
 714                                 }
 715                                 else if(strncmp(optarg,"VKF",3)==0){
 716                                         vars_to_check=CHECK_VKF;
 717                                         volume_name = strscpy(volume_name,optarg+3);
 718                                         if(!strcmp(volume_name,""))
 719                                                 volume_name = strscpy(volume_name,"SYS");
 720                                 }
 721                                 else if(!strcmp(optarg,"DSDB"))
 722                                         vars_to_check=CHECK_DSDB;
 723                                 else if(!strcmp(optarg,"LOGINS"))
 724                                         vars_to_check=CHECK_LOGINS;
 725                                 else if(!strcmp(optarg,"UPRB"))
 726                                         vars_to_check=CHECK_UPRB;
 727                                 else if(!strcmp(optarg,"PUPRB"))
 728                                         vars_to_check=CHECK_PUPRB;
 729                                 else if(!strncmp(optarg,"SAPENTRIES",10)){
 730                                         vars_to_check=CHECK_SAPENTRIES;
 731                                         if(strlen(optarg)>10)
 732                                                 sap_number=atoi(optarg+10);
 733                                         else
 734                                                 sap_number=-1;
 735                                 }
 736                                 else if(!strcmp(optarg,"OFILES"))
 737                                         vars_to_check=CHECK_OFILES;
 738                                 else if(strncmp(optarg,"VKP",3)==0){
 739                                         vars_to_check=CHECK_VKP;
 740                                         volume_name = strscpy(volume_name,optarg+3);
 741                                         if(!strcmp(volume_name,""))
 742                                                 volume_name = strscpy(volume_name,"SYS");
 743                                 }
 744                                 else if(strncmp(optarg,"VPP",3)==0){
 745                                         vars_to_check=CHECK_VPP;
 746                                         volume_name = strscpy(volume_name,optarg+3);
 747                                         if(!strcmp(volume_name,""))
 748                                                 volume_name = strscpy(volume_name,"SYS");
 749                                 }
 750                                 else if(strncmp(optarg,"VKNP",4)==0){
 751                                         vars_to_check=CHECK_VKNP;
 752                                         volume_name = strscpy(volume_name,optarg+4);
 753                                         if(!strcmp(volume_name,""))
 754                                                 volume_name = strscpy(volume_name,"SYS");
 755                                 }
 756                                 else if(strncmp(optarg,"VPNP",4)==0){
 757                                         vars_to_check=CHECK_VPNP;
 758                                         volume_name = strscpy(volume_name,optarg+4);
 759                                         if(!strcmp(volume_name,""))
 760                                                 volume_name = strscpy(volume_name,"SYS");
 761                                 }
 762                                 else if(!strcmp(optarg,"ABENDS"))
 763                                         vars_to_check=CHECK_ABENDS;
 764                                 else if(!strcmp(optarg,"CSPROCS"))
 765                                         vars_to_check=CHECK_CSPROCS;
 766                                 else
 767                                         return ERROR;
 768                                 break;
 769                         case 'w': /* warning threshold */
 770                                 warning_value=strtoul(optarg,NULL,10);
 771                                 check_warning_value=TRUE;
 772                                 break;
 773                         case 'c': /* critical threshold */
 774                                 critical_value=strtoul(optarg,NULL,10);
 775                                 check_critical_value=TRUE;
 776                                 break;
 777                         case 't': /* timeout */
 778                                 socket_timeout=atoi(optarg);
 779                                 if(socket_timeout<=0)
 780                                         return ERROR;
 781                         }
 782
 783         }
 784
 785         return OK;
 786 }
 787
 788
 789 void print_usage(void)
 790 {
 791         printf
 792                 ("Usage:\n"
 793                  " %s %s\n"
 794                  " %s (-h | --help) for detailed help\n"
 795                  " %s (-V | --version) for version information\n",
 796                  progname, OPTIONS, progname, progname);
 797 }
 798
 799 void print_help(void)
 800 {
 801         print_revision (progname, REVISION);
 802         printf ("%s\n\n%s\n", COPYRIGHT, SUMMARY);
 803         print_usage();
 804         printf
 805                 ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n",
 806                  PORT, DEFAULT_SOCKET_TIMEOUT);
 807         support ();
 808 }