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