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