plugins/check_nwstat.c

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