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