plugins/check_nwstat.c

   1 /******************************************************************************
   2
   3  This program is free software; you can redistribute it and/or modify
   4  it under the terms of the GNU General Public License as published by
   5  the Free Software Foundation; either version 2 of the License, or
   6  (at your option) any later version.
   7
   8  This program is distributed in the hope that it will be useful,
   9  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  GNU General Public License for more details.
  12
  13  You should have received a copy of the GNU General Public License
  14  along with this program; if not, write to the Free Software
  15  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16
  17  $Id$
  18
  19 ******************************************************************************/
  20
  21 const char *progname = "check_nwstat";
  22 const char *revision = "$Revision$";
  23 const char *copyright = "2000-2006";
  24 const char *email = "nagiosplug-devel@lists.sourceforge.net";
  25
  26 #include "common.h"
  27 #include "netutils.h"
  28 #include "utils.h"
  29
  30 enum checkvar {
  31         NONE,
  32         LOAD1,      /* check 1 minute CPU load */
  33         LOAD5,      /* check 5 minute CPU load */
  34         LOAD15,     /* check 15 minute CPU load */
  35         CONNS,      /* check number of connections */
  36         VPF,        /* check % free space on volume */
  37         VKF,        /* check KB free space on volume */
  38         LTCH,       /* check long-term cache hit percentage */
  39         CBUFF,      /* check total cache buffers */
  40         CDBUFF,     /* check dirty cache buffers */
  41         LRUM,       /* check LRU sitting time in minutes */
  42         DSDB,       /* check to see if DS Database is open */
  43         LOGINS,     /* check to see if logins are enabled */
  44         PUPRB,      /* check % of used packet receive buffers */
  45         UPRB,       /* check used packet receive buffers */
  46         SAPENTRIES, /* check SAP entries */
  47         OFILES,     /* check number of open files */
  48         VKP,        /* check KB purgeable space on volume */
  49         VPP,        /* check % purgeable space on volume */
  50         VKNP,       /* check KB not yet purgeable space on volume */
  51         VPNP,       /* check % not yet purgeable space on volume */
  52         ABENDS,     /* check abended thread count */
  53         CSPROCS,    /* check number of current service processes */
  54         TSYNC,      /* check timesync status 0=no 1=yes in sync to the network */
  55         LRUS,       /* check LRU sitting time in seconds */
  56         DCB,        /* check dirty cache buffers as a percentage of the total */
  57         TCB,        /* check total cache buffers as a percentage of the original */
  58         DSVER,      /* check NDS version */
  59         UPTIME,     /* check server uptime */
  60         NLM         /* check NLM loaded */
  61 };
  62
  63 enum {
  64         PORT = 9999
  65 };
  66
  67 char *server_address=NULL;
  68 char *volume_name=NULL;
  69 char *nlm_name=NULL;
  70 int server_port=PORT;
  71 unsigned long warning_value=0L;
  72 unsigned long critical_value=0L;
  73 int check_warning_value=FALSE;
  74 int check_critical_value=FALSE;
  75 int check_netware_version=FALSE;
  76 enum checkvar vars_to_check = NONE;
  77 int sap_number=-1;
  78
  79 int process_arguments(int, char **);
  80 void print_help(void);
  81 void print_usage(void);
  82
  83
  84
  85 int
  86 main(int argc, char **argv) {
  87         int result = STATE_UNKNOWN;
  88         int sd;
  89         char *send_buffer=NULL;
  90         char recv_buffer[MAX_INPUT_BUFFER];
  91         char *output_message=NULL;
  92         char *temp_buffer=NULL;
  93         char *netware_version=NULL;
  94
  95         int time_sync_status=0;
  96         unsigned long total_cache_buffers=0;
  97         unsigned long dirty_cache_buffers=0;
  98         unsigned long open_files=0;
  99         unsigned long abended_threads=0;
 100         unsigned long max_service_processes=0;
 101         unsigned long current_service_processes=0;
 102         unsigned long free_disk_space=0L;
 103         unsigned long total_disk_space=0L;
 104         unsigned long purgeable_disk_space=0L;
 105         unsigned long non_purgeable_disk_space=0L;
 106         unsigned long percent_free_space=0;
 107         unsigned long percent_purgeable_space=0;
 108         unsigned long percent_non_purgeable_space=0;
 109         unsigned long current_connections=0L;
 110         unsigned long utilization=0L;
 111         unsigned long cache_hits=0;
 112         unsigned long cache_buffers=0L;
 113         unsigned long lru_time=0L;
 114         unsigned long max_packet_receive_buffers=0;
 115         unsigned long used_packet_receive_buffers=0;
 116         unsigned long percent_used_packet_receive_buffers=0L;
 117         unsigned long sap_entries=0;
 118         char uptime[MAX_INPUT_BUFFER];
 119
 120         setlocale (LC_ALL, "");
 121         bindtextdomain (PACKAGE, LOCALEDIR);
 122         textdomain (PACKAGE);
 123
 124         if (process_arguments(argc,argv) == ERROR)
 125                 usage4 (_("Could not parse arguments"));
 126
 127         /* initialize alarm signal handling */
 128         signal(SIGALRM,socket_timeout_alarm_handler);
 129
 130         /* set socket timeout */
 131         alarm(socket_timeout);
 132
 133         /* open connection */
 134         my_tcp_connect (server_address, server_port, &sd);
 135
 136         /* get OS version string */
 137         if (check_netware_version==TRUE) {
 138                 send_buffer = strdup ("S19\r\n");
 139                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 140                 if (result!=STATE_OK)
 141                         return result;
 142                 if (!strcmp(recv_buffer,"-1\n"))
 143                         netware_version = strdup("");
 144                 else {
 145                         recv_buffer[strlen(recv_buffer)-1]=0;
 146                         asprintf (&netware_version,_("NetWare %s: "),recv_buffer);
 147                 }
 148         } else
 149                 netware_version = strdup("");
 150
 151
 152         /* check CPU load */
 153         if (vars_to_check==LOAD1 || vars_to_check==LOAD5 || vars_to_check==LOAD15) {
 154
 155                 switch(vars_to_check) {
 156                 case LOAD1:
 157                         temp_buffer = strdup ("1");
 158                         break;
 159                 case LOAD5:
 160                         temp_buffer = strdup ("5");
 161                         break;
 162                 default:
 163                         temp_buffer = strdup ("15");
 164                         break;
 165                 }
 166
 167                 close(sd);
 168                 my_tcp_connect (server_address, server_port, &sd);
 169
 170                 asprintf (&send_buffer,"UTIL%s\r\n",temp_buffer);
 171                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 172                 if (result!=STATE_OK)
 173                         return result;
 174                 utilization=strtoul(recv_buffer,NULL,10);
 175
 176                 close(sd);
 177                 my_tcp_connect (server_address, server_port, &sd);
 178
 179                 send_buffer = strdup ("UPTIME\r\n");
 180                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 181                 if (result!=STATE_OK)
 182                         return result;
 183                 recv_buffer[strlen(recv_buffer)-1]=0;
 184                 sprintf(uptime,_("Up %s,"),recv_buffer);
 185
 186                 if (check_critical_value==TRUE && utilization >= critical_value)
 187                         result=STATE_CRITICAL;
 188                 else if (check_warning_value==TRUE && utilization >= warning_value)
 189                         result=STATE_WARNING;
 190
 191                 asprintf (&output_message,
 192                           _("Load %s - %s %s-min load average = %lu%%"),
 193                           state_text(result),
 194                           uptime,
 195                           temp_buffer,
 196                           utilization);
 197
 198                 /* check number of user connections */
 199         } else if (vars_to_check==CONNS) {
 200
 201                 close(sd);
 202                 my_tcp_connect (server_address, server_port, &sd);
 203
 204                 send_buffer = strdup ("CONNECT\r\n");
 205                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 206                 if (result!=STATE_OK)
 207                         return result;
 208                 current_connections=strtoul(recv_buffer,NULL,10);
 209
 210                 if (check_critical_value==TRUE && current_connections >= critical_value)
 211                         result=STATE_CRITICAL;
 212                 else if (check_warning_value==TRUE && current_connections >= warning_value)
 213                         result=STATE_WARNING;
 214
 215                 asprintf (&output_message,
 216                                                         _("Conns %s - %lu current connections"),
 217                           state_text(result),
 218                           current_connections);
 219
 220                 /* check % long term cache hits */
 221         } else if (vars_to_check==LTCH) {
 222
 223                 close(sd);
 224                 my_tcp_connect (server_address, server_port, &sd);
 225
 226                 send_buffer = strdup ("S1\r\n");
 227                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 228                 if (result!=STATE_OK)
 229                         return result;
 230                 cache_hits=atoi(recv_buffer);
 231
 232                 if (check_critical_value==TRUE && cache_hits <= critical_value)
 233                         result=STATE_CRITICAL;
 234                 else if (check_warning_value==TRUE && cache_hits <= warning_value)
 235                         result=STATE_WARNING;
 236
 237                 asprintf (&output_message,
 238                           _("%s: Long term cache hits = %lu%%"),
 239                           state_text(result),
 240                           cache_hits);
 241
 242                 /* check cache buffers */
 243         } else if (vars_to_check==CBUFF) {
 244
 245                 close(sd);
 246                 my_tcp_connect (server_address, server_port, &sd);
 247
 248                 send_buffer = strdup ("S2\r\n");
 249                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 250                 if (result!=STATE_OK)
 251                         return result;
 252                 cache_buffers=strtoul(recv_buffer,NULL,10);
 253
 254                 if (check_critical_value==TRUE && cache_buffers <= critical_value)
 255                         result=STATE_CRITICAL;
 256                 else if (check_warning_value==TRUE && cache_buffers <= warning_value)
 257                         result=STATE_WARNING;
 258
 259                 asprintf (&output_message,
 260                           _("%s: Total cache buffers = %lu"),
 261                           state_text(result),
 262                           cache_buffers);
 263
 264                 /* check dirty cache buffers */
 265         } else if (vars_to_check==CDBUFF) {
 266
 267                 close(sd);
 268                 my_tcp_connect (server_address, server_port, &sd);
 269
 270                 send_buffer = strdup ("S3\r\n");
 271                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 272                 if (result!=STATE_OK)
 273                         return result;
 274                 cache_buffers=strtoul(recv_buffer,NULL,10);
 275
 276                 if (check_critical_value==TRUE && cache_buffers >= critical_value)
 277                         result=STATE_CRITICAL;
 278                 else if (check_warning_value==TRUE && cache_buffers >= warning_value)
 279                         result=STATE_WARNING;
 280
 281                 asprintf (&output_message,
 282                           _("%s: Dirty cache buffers = %lu"),
 283                           state_text(result),
 284                           cache_buffers);
 285
 286                 /* check LRU sitting time in minutes */
 287         } else if (vars_to_check==LRUM) {
 288
 289                 close(sd);
 290                 my_tcp_connect (server_address, server_port, &sd);
 291
 292                 send_buffer = strdup ("S5\r\n");
 293                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 294                 if (result!=STATE_OK)
 295                         return result;
 296                 lru_time=strtoul(recv_buffer,NULL,10);
 297
 298                 if (check_critical_value==TRUE && lru_time <= critical_value)
 299                         result=STATE_CRITICAL;
 300                 else if (check_warning_value==TRUE && lru_time <= warning_value)
 301                         result=STATE_WARNING;
 302
 303                 asprintf (&output_message,
 304                           _("%s: LRU sitting time = %lu minutes"),
 305                           state_text(result),
 306                           lru_time);
 307
 308
 309                 /* check KB free space on volume */
 310         } else if (vars_to_check==VKF) {
 311
 312                 close(sd);
 313                 my_tcp_connect (server_address, server_port, &sd);
 314
 315                 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
 316                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 317                 if (result!=STATE_OK)
 318                         return result;
 319
 320                 if (!strcmp(recv_buffer,"-1\n")) {
 321                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 322                         result=STATE_CRITICAL;
 323                 }       else {
 324                         free_disk_space=strtoul(recv_buffer,NULL,10);
 325                         if (check_critical_value==TRUE && free_disk_space <= critical_value)
 326                                 result=STATE_CRITICAL;
 327                         else if (check_warning_value==TRUE && free_disk_space <= warning_value)
 328                                 result=STATE_WARNING;
 329                         asprintf (&output_message,
 330                                   _("%s%lu KB free on volume %s"),
 331                                  (result==STATE_OK)?"":_("Only "),
 332                                  free_disk_space,
 333                                  volume_name);
 334                 }
 335
 336                 /* check % free space on volume */
 337         } else if (vars_to_check==VPF) {
 338
 339                 close(sd);
 340                 my_tcp_connect (server_address, server_port, &sd);
 341
 342                 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
 343                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 344                 if (result!=STATE_OK)
 345                         return result;
 346
 347                 if (!strcmp(recv_buffer,"-1\n")) {
 348
 349                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 350                         result=STATE_CRITICAL;
 351
 352                 } else {
 353
 354                         free_disk_space=strtoul(recv_buffer,NULL,10);
 355
 356                         close(sd);
 357                         my_tcp_connect (server_address, server_port, &sd);
 358
 359                         asprintf (&send_buffer,"VKS%s\r\n",volume_name);
 360                         result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 361                         if (result!=STATE_OK)
 362                                 return result;
 363                         total_disk_space=strtoul(recv_buffer,NULL,10);
 364
 365                         percent_free_space=(unsigned long)(((double)free_disk_space/(double)total_disk_space)*100.0);
 366
 367                         if (check_critical_value==TRUE && percent_free_space <= critical_value)
 368                                 result=STATE_CRITICAL;
 369                         else if (check_warning_value==TRUE && percent_free_space <= warning_value)
 370                                 result=STATE_WARNING;
 371                         free_disk_space/=1024;
 372                         total_disk_space/=1024;
 373                         asprintf (&output_message,_("%lu MB (%lu%%) free on volume %s - total %lu MB"),free_disk_space,percent_free_space,volume_name,total_disk_space);
 374                 }
 375
 376                 /* check to see if DS Database is open or closed */
 377         } else if (vars_to_check==DSDB) {
 378
 379                 close(sd);
 380                 my_tcp_connect (server_address, server_port, &sd);
 381
 382                 send_buffer = strdup ("S11\r\n");
 383                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 384                 if (result!=STATE_OK)
 385                         return result;
 386                 if (atoi(recv_buffer)==1)
 387                         result=STATE_OK;
 388                 else
 389                         result=STATE_WARNING;
 390
 391                 close(sd);
 392                 my_tcp_connect (server_address, server_port, &sd);
 393
 394                 send_buffer = strdup ("S13\r\n");
 395                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 396                 temp_buffer=strtok(recv_buffer,"\r\n");
 397
 398                 asprintf (&output_message,_("Directory Services Database is %s (DS version %s)"),(result==STATE_OK)?"open":"closed",temp_buffer);
 399
 400                 /* check to see if logins are enabled */
 401         } else if (vars_to_check==LOGINS) {
 402
 403                 close(sd);
 404                 my_tcp_connect (server_address, server_port, &sd);
 405
 406                 send_buffer = strdup ("S12\r\n");
 407                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 408                 if (result!=STATE_OK)
 409                         return result;
 410                 if (atoi(recv_buffer)==1)
 411                         result=STATE_OK;
 412                 else
 413                         result=STATE_WARNING;
 414
 415                 asprintf (&output_message,_("Logins are %s"),(result==STATE_OK)?_("enabled"):_("disabled"));
 416
 417                 /* check packet receive buffers */
 418         } else if (vars_to_check==UPRB || vars_to_check==PUPRB) {
 419
 420                 close(sd);
 421                 my_tcp_connect (server_address, server_port, &sd);
 422
 423                 asprintf (&send_buffer,"S15\r\n");
 424                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 425                 if (result!=STATE_OK)
 426                         return result;
 427
 428                 used_packet_receive_buffers=atoi(recv_buffer);
 429
 430                 close(sd);
 431                 my_tcp_connect (server_address, server_port, &sd);
 432
 433                 asprintf (&send_buffer,"S16\r\n");
 434                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 435                 if (result!=STATE_OK)
 436                         return result;
 437
 438                 max_packet_receive_buffers=atoi(recv_buffer);
 439
 440                 percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
 441
 442                 if (vars_to_check==UPRB) {
 443                         if (check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
 444                                 result=STATE_CRITICAL;
 445                         else if (check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
 446                                 result=STATE_WARNING;
 447                 } else {
 448                         if (check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
 449                                 result=STATE_CRITICAL;
 450                         else if (check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
 451                                 result=STATE_WARNING;
 452                 }
 453
 454                 asprintf (&output_message,_("%lu of %lu (%lu%%) packet receive buffers used"),used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
 455
 456                 /* check SAP table entries */
 457         } else if (vars_to_check==SAPENTRIES) {
 458
 459                 close(sd);
 460                 my_tcp_connect (server_address, server_port, &sd);
 461
 462                 if (sap_number==-1)
 463                         asprintf (&send_buffer,"S9\r\n");
 464                 else
 465                         asprintf (&send_buffer,"S9.%d\r\n",sap_number);
 466                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 467                 if (result!=STATE_OK)
 468                         return result;
 469
 470                 sap_entries=atoi(recv_buffer);
 471
 472                 if (check_critical_value==TRUE && sap_entries >= critical_value)
 473                         result=STATE_CRITICAL;
 474                 else if (check_warning_value==TRUE && sap_entries >= warning_value)
 475                         result=STATE_WARNING;
 476
 477                 if (sap_number==-1)
 478                         asprintf (&output_message,_("%lu entries in SAP table"),sap_entries);
 479                 else
 480                         asprintf (&output_message,_("%lu entries in SAP table for SAP type %d"),sap_entries,sap_number);
 481
 482                 /* check KB purgeable space on volume */
 483         } else if (vars_to_check==VKP) {
 484
 485                 close(sd);
 486                 my_tcp_connect (server_address, server_port, &sd);
 487
 488                 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
 489                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 490                 if (result!=STATE_OK)
 491                         return result;
 492
 493                 if (!strcmp(recv_buffer,"-1\n")) {
 494                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 495                         result=STATE_CRITICAL;
 496                 } else {
 497                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 498                         if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
 499                                 result=STATE_CRITICAL;
 500                         else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
 501                                 result=STATE_WARNING;
 502                         asprintf (&output_message,_("%s%lu KB purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),purgeable_disk_space,volume_name);
 503                 }
 504
 505                 /* check % purgeable space on volume */
 506         } else if (vars_to_check==VPP) {
 507
 508                 close(sd);
 509                 my_tcp_connect (server_address, server_port, &sd);
 510
 511                 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
 512                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 513                 if (result!=STATE_OK)
 514                         return result;
 515
 516                 if (!strcmp(recv_buffer,"-1\n")) {
 517
 518                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 519                         result=STATE_CRITICAL;
 520
 521                 } else {
 522
 523                         purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 524
 525                         close(sd);
 526                         my_tcp_connect (server_address, server_port, &sd);
 527
 528                         asprintf (&send_buffer,"VKS%s\r\n",volume_name);
 529                         result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 530                         if (result!=STATE_OK)
 531                                 return result;
 532                         total_disk_space=strtoul(recv_buffer,NULL,10);
 533
 534                         percent_purgeable_space=(unsigned long)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
 535
 536                         if (check_critical_value==TRUE && percent_purgeable_space >= critical_value)
 537                                 result=STATE_CRITICAL;
 538                         else if (check_warning_value==TRUE && percent_purgeable_space >= warning_value)
 539                                 result=STATE_WARNING;
 540                         purgeable_disk_space/=1024;
 541                         asprintf (&output_message,_("%lu MB (%lu%%) purgeable on volume %s"),purgeable_disk_space,percent_purgeable_space,volume_name);
 542                 }
 543
 544                 /* check KB not yet purgeable space on volume */
 545         } else if (vars_to_check==VKNP) {
 546
 547                 close(sd);
 548                 my_tcp_connect (server_address, server_port, &sd);
 549
 550                 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
 551                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 552                 if (result!=STATE_OK)
 553                         return result;
 554
 555                 if (!strcmp(recv_buffer,"-1\n")) {
 556                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 557                         result=STATE_CRITICAL;
 558                 } else {
 559                         non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 560                         if (check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
 561                                 result=STATE_CRITICAL;
 562                         else if (check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
 563                                 result=STATE_WARNING;
 564                         asprintf (&output_message,_("%s%lu KB not yet purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),non_purgeable_disk_space,volume_name);
 565                 }
 566
 567                 /* check % not yet purgeable space on volume */
 568         } else if (vars_to_check==VPNP) {
 569
 570                 close(sd);
 571                 my_tcp_connect (server_address, server_port, &sd);
 572
 573                 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
 574                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 575                 if (result!=STATE_OK)
 576                         return result;
 577
 578                 if (!strcmp(recv_buffer,"-1\n")) {
 579
 580                         asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
 581                         result=STATE_CRITICAL;
 582
 583                 } else {
 584
 585                         non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
 586
 587                         close(sd);
 588                         my_tcp_connect (server_address, server_port, &sd);
 589
 590                         asprintf (&send_buffer,"VKS%s\r\n",volume_name);
 591                         result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 592                         if (result!=STATE_OK)
 593                                 return result;
 594                         total_disk_space=strtoul(recv_buffer,NULL,10);
 595
 596                         percent_non_purgeable_space=(unsigned long)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
 597
 598                         if (check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
 599                                 result=STATE_CRITICAL;
 600                         else if (check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
 601                                 result=STATE_WARNING;
 602                         purgeable_disk_space/=1024;
 603                         asprintf (&output_message,_("%lu MB (%lu%%) not yet purgeable on volume %s"),non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
 604                 }
 605
 606                 /* check # of open files */
 607         } else if (vars_to_check==OFILES) {
 608
 609                 close(sd);
 610                 my_tcp_connect (server_address, server_port, &sd);
 611
 612                 asprintf (&send_buffer,"S18\r\n");
 613                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 614                 if (result!=STATE_OK)
 615                         return result;
 616
 617                 open_files=atoi(recv_buffer);
 618
 619                 if (check_critical_value==TRUE && open_files >= critical_value)
 620                         result=STATE_CRITICAL;
 621                 else if (check_warning_value==TRUE && open_files >= warning_value)
 622                         result=STATE_WARNING;
 623
 624                 asprintf (&output_message,_("%lu open files"),open_files);
 625
 626                 /* check # of abended threads (Netware 5.x only) */
 627         } else if (vars_to_check==ABENDS) {
 628
 629                 close(sd);
 630                 my_tcp_connect (server_address, server_port, &sd);
 631
 632                 asprintf (&send_buffer,"S17\r\n");
 633                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 634                 if (result!=STATE_OK)
 635                         return result;
 636
 637                 abended_threads=atoi(recv_buffer);
 638
 639                 if (check_critical_value==TRUE && abended_threads >= critical_value)
 640                         result=STATE_CRITICAL;
 641                 else if (check_warning_value==TRUE && abended_threads >= warning_value)
 642                         result=STATE_WARNING;
 643
 644                 asprintf (&output_message,_("%lu abended threads"),abended_threads);
 645
 646                 /* check # of current service processes (Netware 5.x only) */
 647         } else if (vars_to_check==CSPROCS) {
 648
 649                 close(sd);
 650                 my_tcp_connect (server_address, server_port, &sd);
 651
 652                 asprintf (&send_buffer,"S20\r\n");
 653                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 654                 if (result!=STATE_OK)
 655                         return result;
 656
 657                 max_service_processes=atoi(recv_buffer);
 658
 659                 close(sd);
 660                 my_tcp_connect (server_address, server_port, &sd);
 661
 662                 asprintf (&send_buffer,"S21\r\n");
 663                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 664                 if (result!=STATE_OK)
 665                         return result;
 666
 667                 current_service_processes=atoi(recv_buffer);
 668
 669                 if (check_critical_value==TRUE && current_service_processes >= critical_value)
 670                         result=STATE_CRITICAL;
 671                 else if (check_warning_value==TRUE && current_service_processes >= warning_value)
 672                         result=STATE_WARNING;
 673
 674                 asprintf (&output_message,
 675                           _("%lu current service processes (%lu max)"),
 676                           current_service_processes,
 677                           max_service_processes);
 678
 679                 /* check # Timesync Status */
 680         } else if (vars_to_check==TSYNC) {
 681
 682                 close(sd);
 683                 my_tcp_connect (server_address, server_port, &sd);
 684
 685                 asprintf (&send_buffer,"S22\r\n");
 686                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 687                 if (result!=STATE_OK)
 688                         return result;
 689
 690                 time_sync_status=atoi(recv_buffer);
 691
 692                 if (time_sync_status==0) {
 693                         result=STATE_CRITICAL;
 694                         asprintf (&output_message,_("CRITICAL - Time not in sync with network!"));
 695                 }
 696                 else {
 697                         asprintf (&output_message,_("OK - Time in sync with network!"));
 698                 }
 699
 700                 /* check LRU sitting time in secondss */
 701         } else if (vars_to_check==LRUS) {
 702
 703                 close(sd);
 704                 my_tcp_connect (server_address, server_port, &sd);
 705
 706                 send_buffer = strdup ("S4\r\n");
 707                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 708                 if (result!=STATE_OK)
 709                         return result;
 710                 lru_time=strtoul(recv_buffer,NULL,10);
 711
 712                 if (check_critical_value==TRUE && lru_time <= critical_value)
 713                         result=STATE_CRITICAL;
 714                 else if (check_warning_value==TRUE && lru_time <= warning_value)
 715                         result=STATE_WARNING;
 716                 asprintf (&output_message,_("LRU sitting time = %lu seconds"),lru_time);
 717
 718
 719                 /* check % dirty cacheobuffers as a percentage of the total*/
 720         } else if (vars_to_check==DCB) {
 721
 722                 close(sd);
 723                 my_tcp_connect (server_address, server_port, &sd);
 724
 725                 send_buffer = strdup ("S6\r\n");
 726                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 727                 if (result!=STATE_OK)
 728                         return result;
 729                 dirty_cache_buffers=atoi(recv_buffer);
 730
 731                 if (check_critical_value==TRUE && dirty_cache_buffers <= critical_value)
 732                         result=STATE_CRITICAL;
 733                 else if (check_warning_value==TRUE && dirty_cache_buffers <= warning_value)
 734                         result=STATE_WARNING;
 735                 asprintf (&output_message,_("Dirty cache buffers = %lu%% of the total"),dirty_cache_buffers);
 736
 737                 /* check % total cache buffers as a percentage of the original*/
 738         } else if (vars_to_check==TCB) {
 739
 740                 close(sd);
 741                 my_tcp_connect (server_address, server_port, &sd);
 742
 743                 send_buffer = strdup ("S7\r\n");
 744                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 745                 if (result!=STATE_OK)
 746                         return result;
 747                 total_cache_buffers=atoi(recv_buffer);
 748
 749                 if (check_critical_value==TRUE && total_cache_buffers <= critical_value)
 750                         result=STATE_CRITICAL;
 751                 else if (check_warning_value==TRUE && total_cache_buffers <= warning_value)
 752                         result=STATE_WARNING;
 753                 asprintf (&output_message,_("Total cache buffers = %lu%% of the original"),total_cache_buffers);
 754
 755         } else if (vars_to_check==DSVER) {
 756
 757                 close(sd);
 758                 my_tcp_connect (server_address, server_port, &sd);
 759
 760                 asprintf (&send_buffer,"S13\r\n");
 761                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 762                 if (result!=STATE_OK)
 763                         return result;
 764
 765                 recv_buffer[strlen(recv_buffer)-1]=0;
 766
 767                 asprintf (&output_message,_("NDS Version %s"),recv_buffer);
 768
 769         } else if (vars_to_check==UPTIME) {
 770
 771                 close(sd);
 772                 my_tcp_connect (server_address, server_port, &sd);
 773
 774                 asprintf (&send_buffer,"UPTIME\r\n");
 775                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 776                 if (result!=STATE_OK)
 777                         return result;
 778
 779
 780                 recv_buffer[sizeof(recv_buffer)-1]=0;
 781                 recv_buffer[strlen(recv_buffer)-1]=0;
 782
 783                 asprintf (&output_message,_("Up %s"),recv_buffer);
 784
 785         } else if (vars_to_check==NLM) {
 786
 787                 close(sd);
 788                 my_tcp_connect (server_address, server_port, &sd);
 789
 790                 asprintf (&send_buffer,"S24:%s\r\n",nlm_name);
 791                 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
 792                 if (result!=STATE_OK)
 793                         return result;
 794
 795                 recv_buffer[strlen(recv_buffer)-1]=0;
 796                 if (strcmp(recv_buffer,"-1")) {
 797                         asprintf (&output_message,_("Module %s version %s is loaded"),nlm_name,recv_buffer);
 798                 } else {
 799                         result=STATE_CRITICAL;
 800                         asprintf (&output_message,_("Module %s is not loaded"),nlm_name);
 801                 }
 802
 803         } else {
 804
 805                 output_message = strdup (_("Nothing to check!\n"));
 806                 result=STATE_UNKNOWN;
 807
 808         }
 809
 810         close (sd);
 811
 812         /* reset timeout */
 813         alarm(0);
 814
 815         printf("%s%s\n",netware_version,output_message);
 816
 817         return result;
 818 }
 819
 820
 821
 822 /* process command-line arguments */
 823 int process_arguments(int argc, char **argv) {
 824         int c;
 825
 826         int option = 0;
 827         static struct option longopts[] =
 828                 {
 829                         {"port",     required_argument,0,'p'},
 830                         {"timeout",  required_argument,0,'t'},
 831                         {"critical", required_argument,0,'c'},
 832                         {"warning",  required_argument,0,'w'},
 833                         {"variable", required_argument,0,'v'},
 834                         {"hostname", required_argument,0,'H'},
 835                         {"osversion",no_argument,      0,'o'},
 836                         {"version",  no_argument,      0,'V'},
 837                         {"help",     no_argument,      0,'h'},
 838                         {0,0,0,0}
 839                 };
 840
 841         /* no options were supplied */
 842         if (argc<2) return ERROR;
 843
 844         /* backwards compatibility */
 845         if (! is_option(argv[1])) {
 846                 server_address=argv[1];
 847                 argv[1]=argv[0];
 848                 argv=&argv[1];
 849                 argc--;
 850         }
 851
 852   for (c=1;c<argc;c++) {
 853     if (strcmp("-to",argv[c])==0)
 854       strcpy(argv[c],"-t");
 855     else if (strcmp("-wv",argv[c])==0)
 856       strcpy(argv[c],"-w");
 857     else if (strcmp("-cv",argv[c])==0)
 858       strcpy(argv[c],"-c");
 859         }
 860
 861         while (1) {
 862                 c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",longopts,&option);
 863
 864                 if (c==-1||c==EOF||c==1)
 865                         break;
 866
 867                 switch (c)
 868                         {
 869                         case '?': /* print short usage statement if args not parsable */
 870                         usage2 (_("Unknown argument"), optarg);
 871                         case 'h': /* help */
 872                                 print_help();
 873                                 exit(STATE_OK);
 874                         case 'V': /* version */
 875                                 print_revision(progname, revision);
 876                                 exit(STATE_OK);
 877                         case 'H': /* hostname */
 878                                 server_address=optarg;
 879                                 break;
 880                         case 'o': /* display nos version */
 881                                 check_netware_version=TRUE;
 882                                 break;
 883                         case 'p': /* port */
 884                                 if (is_intnonneg(optarg))
 885                                         server_port=atoi(optarg);
 886                                 else
 887                                         die(STATE_UNKNOWN,_("Server port an integer\n"));
 888                                 break;
 889                         case 'v':
 890                                 if (strlen(optarg)<3)
 891                                         return ERROR;
 892                                 if (!strcmp(optarg,"LOAD1"))
 893                                         vars_to_check=LOAD1;
 894                                 else if (!strcmp(optarg,"LOAD5"))
 895                                         vars_to_check=LOAD5;
 896                                 else if (!strcmp(optarg,"LOAD15"))
 897                                         vars_to_check=LOAD15;
 898                                 else if (!strcmp(optarg,"CONNS"))
 899                                         vars_to_check=CONNS;
 900                                 else if (!strcmp(optarg,"LTCH"))
 901                                         vars_to_check=LTCH;
 902                                 else if (!strcmp(optarg,"DCB"))
 903                                         vars_to_check=DCB;
 904                                 else if (!strcmp(optarg,"TCB"))
 905                                         vars_to_check=TCB;
 906                                 else if (!strcmp(optarg,"CBUFF"))
 907                                         vars_to_check=CBUFF;
 908                                 else if (!strcmp(optarg,"CDBUFF"))
 909                                         vars_to_check=CDBUFF;
 910                                 else if (!strcmp(optarg,"LRUM"))
 911                                         vars_to_check=LRUM;
 912                                 else if (!strcmp(optarg,"LRUS"))
 913                                         vars_to_check=LRUS;
 914                                 else if (strncmp(optarg,"VPF",3)==0) {
 915                                         vars_to_check=VPF;
 916                                         volume_name = strdup (optarg+3);
 917                                         if (!strcmp(volume_name,""))
 918                                                 volume_name = strdup ("SYS");
 919                                 }
 920                                 else if (strncmp(optarg,"VKF",3)==0) {
 921                                         vars_to_check=VKF;
 922                                         volume_name = strdup (optarg+3);
 923                                         if (!strcmp(volume_name,""))
 924                                                 volume_name = strdup ("SYS");
 925                                 }
 926                                 else if (!strcmp(optarg,"DSDB"))
 927                                         vars_to_check=DSDB;
 928                                 else if (!strcmp(optarg,"LOGINS"))
 929                                         vars_to_check=LOGINS;
 930                                 else if (!strcmp(optarg,"UPRB"))
 931                                         vars_to_check=UPRB;
 932                                 else if (!strcmp(optarg,"PUPRB"))
 933                                         vars_to_check=PUPRB;
 934                                 else if (!strncmp(optarg,"SAPENTRIES",10)) {
 935                                         vars_to_check=SAPENTRIES;
 936                                         if (strlen(optarg)>10)
 937                                                 sap_number=atoi(optarg+10);
 938                                         else
 939                                                 sap_number=-1;
 940                                 }
 941                                 else if (!strcmp(optarg,"OFILES"))
 942                                         vars_to_check=OFILES;
 943                                 else if (strncmp(optarg,"VKP",3)==0) {
 944                                         vars_to_check=VKP;
 945                                         volume_name = strdup (optarg+3);
 946                                         if (!strcmp(volume_name,""))
 947                                                 volume_name = strdup ("SYS");
 948                                 }
 949                                 else if (strncmp(optarg,"VPP",3)==0) {
 950                                         vars_to_check=VPP;
 951                                         volume_name = strdup (optarg+3);
 952                                         if (!strcmp(volume_name,""))
 953                                                 volume_name = strdup ("SYS");
 954                                 }
 955                                 else if (strncmp(optarg,"VKNP",4)==0) {
 956                                         vars_to_check=VKNP;
 957                                         volume_name = strdup (optarg+4);
 958                                         if (!strcmp(volume_name,""))
 959                                                 volume_name = strdup ("SYS");
 960                                 }
 961                                 else if (strncmp(optarg,"VPNP",4)==0) {
 962                                         vars_to_check=VPNP;
 963                                         volume_name = strdup (optarg+4);
 964                                         if (!strcmp(volume_name,""))
 965                                                 volume_name = strdup("SYS");
 966                                 }
 967                                 else if (!strcmp(optarg,"ABENDS"))
 968                                         vars_to_check=ABENDS;
 969                                 else if (!strcmp(optarg,"CSPROCS"))
 970                                         vars_to_check=CSPROCS;
 971                                 else if (!strcmp(optarg,"TSYNC"))
 972                                         vars_to_check=TSYNC;
 973                                 else if (!strcmp(optarg,"DSVER"))
 974                                         vars_to_check=DSVER;
 975                                 else if (!strcmp(optarg,"UPTIME")) {
 976                                         vars_to_check=UPTIME;
 977                                 }
 978                                 else if (strncmp(optarg,"NLM:",4)==0) {
 979                                         vars_to_check=NLM;
 980                                         nlm_name=strdup (optarg+4);
 981                                 }
 982                                 else
 983                                         return ERROR;
 984                                 break;
 985                         case 'w': /* warning threshold */
 986                                 warning_value=strtoul(optarg,NULL,10);
 987                                 check_warning_value=TRUE;
 988                                 break;
 989                         case 'c': /* critical threshold */
 990                                 critical_value=strtoul(optarg,NULL,10);
 991                                 check_critical_value=TRUE;
 992                                 break;
 993                         case 't': /* timeout */
 994                                 socket_timeout=atoi(optarg);
 995                                 if (socket_timeout<=0)
 996                                         return ERROR;
 997                         }
 998
 999         }
1000
1001         return OK;
1002 }
1003
1004
1005
1006 void print_help(void)
1007 {
1008         char *myport;
1009         asprintf (&myport, "%d", PORT);
1010
1011         print_revision (progname, revision);
1012
1013         printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
1014         printf (COPYRIGHT, copyright, email);
1015
1016         printf ("%s\n", _("This plugin attempts to contact the MRTGEXT NLM running on a"));
1017   printf ("%s\n", _("Novell server to gather the requested system information."));
1018
1019   printf ("\n\n");
1020
1021         print_usage();
1022
1023         printf (_(UT_HELP_VRSN));
1024
1025         printf (_(UT_HOST_PORT), 'p', myport);
1026
1027         printf (_("\
1028  -v, --variable=STRING\n\
1029     Variable to check.  Valid variables include:\n\
1030       LOAD1     = 1 minute average CPU load\n\
1031       LOAD5     = 5 minute average CPU load\n\
1032       LOAD15    = 15 minute average CPU load\n\
1033       CSPROCS   = number of current service processes (NW 5.x only)\n\
1034       ABENDS    = number of abended threads (NW 5.x only)\n\
1035       UPTIME    = server uptime\n"));
1036
1037         printf (_("\
1038       LTCH      = percent long term cache hits\n\
1039       CBUFF     = current number of cache buffers\n\
1040       CDBUFF    = current number of dirty cache buffers\n\
1041       DCB       = dirty cache buffers as a percentage of the total\n\
1042       TCB       = dirty cache buffers as a percentage of the original\n"));
1043
1044         printf (_("\
1045       OFILES    = number of open files\n\
1046       VPF<vol>  = percent free space on volume <vol>\n\
1047       VKF<vol>  = KB of free space on volume <vol>\n\
1048       VPP<vol>  = percent purgeable space on volume <vol>\n\
1049       VKP<vol>  = KB of purgeable space on volume <vol>\n\
1050       VPNP<vol> = percent not yet purgeable space on volume <vol>\n\
1051       VKNP<vol> = KB of not yet purgeable space on volume <vol>\n"));
1052
1053         printf (_("\
1054       LRUM      = LRU sitting time in minutes\n\
1055       LRUS      = LRU sitting time in seconds\n\
1056       DSDB      = check to see if DS Database is open\n\
1057       DSVER     = NDS version\n\
1058       UPRB      = used packet receive buffers\n\
1059       PUPRB     = percent (of max) used packet receive buffers\n\
1060       SAPENTRIES = number of entries in the SAP table\n\
1061       SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>\n"));
1062
1063         printf (_("\
1064       TSYNC     = timesync status \n\
1065       LOGINS    = check to see if logins are enabled\n\
1066       CONNS     = number of currently licensed connections\n\
1067       NLM:<nlm> = check if NLM is loaded and report version\n\
1068                   (e.g. \"NLM:TSANDS.NLM\")\n"));
1069
1070         printf (_("\
1071  -w, --warning=INTEGER\n\
1072     Threshold which will result in a warning status\n\
1073  -c, --critical=INTEGER\n\
1074     Threshold which will result in a critical status\n\
1075  -o, --osversion\n\
1076     Include server version string in results\n"));
1077
1078         printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
1079
1080   printf ("\n");
1081   printf ("%s\n", _("Notes:"));
1082         printf (_("\
1083 - This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG\n\
1084   extension for NetWare be loaded on the Novell servers you wish to check.\n\
1085   (available from http://www.engr.wisc.edu/~drews/mrtg/)\n\
1086 - Values for critical thresholds should be lower than warning thresholds\n\
1087   when the following variables are checked: VPF, VKF, LTCH, CBUFF, DCB, \n\
1088   TCB, LRUS and LRUM.\n"));
1089
1090         printf (_(UT_SUPPORT));
1091 }
1092
1093
1094
1095 void print_usage(void)
1096 {
1097   printf (_("Usage:"));
1098         printf ("%s -H host [-p port] [-v variable] [-w warning] [-c critical] [-t timeout]\n",progname);
1099 }