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