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