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