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);
173 close(sd);
174 my_tcp_connect (server_address, server_port, &sd);
176 send_buffer = strdup ("UPTIME\r\n");
177 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
178 if (result!=STATE_OK)
179 return result;
180 recv_buffer[strlen(recv_buffer)-1]=0;
181 sprintf(uptime,_("Up %s,"),recv_buffer);
183 if (check_critical_value==TRUE && utilization >= critical_value)
184 result=STATE_CRITICAL;
185 else if (check_warning_value==TRUE && utilization >= warning_value)
186 result=STATE_WARNING;
188 asprintf (&output_message,
189 _("Load %s - %s %s-min load average = %lu%%"),
190 state_text(result),
191 uptime,
192 temp_buffer,
193 utilization);
195 /* check number of user connections */
196 } else if (vars_to_check==CONNS) {
198 send_buffer = strdup ("CONNECT\r\n");
199 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
200 if (result!=STATE_OK)
201 return result;
202 current_connections=strtoul(recv_buffer,NULL,10);
204 if (check_critical_value==TRUE && current_connections >= critical_value)
205 result=STATE_CRITICAL;
206 else if (check_warning_value==TRUE && current_connections >= warning_value)
207 result=STATE_WARNING;
209 asprintf (&output_message,
210 _("Conns %s - %lu current connections"),
211 state_text(result),
212 current_connections);
214 /* check % long term cache hits */
215 } else if (vars_to_check==LTCH) {
217 send_buffer = strdup ("S1\r\n");
218 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
219 if (result!=STATE_OK)
220 return result;
221 cache_hits=atoi(recv_buffer);
223 if (check_critical_value==TRUE && cache_hits <= critical_value)
224 result=STATE_CRITICAL;
225 else if (check_warning_value==TRUE && cache_hits <= warning_value)
226 result=STATE_WARNING;
228 asprintf (&output_message,
229 _("%s: Long term cache hits = %lu%%"),
230 state_text(result),
231 cache_hits);
233 /* check cache buffers */
234 } else if (vars_to_check==CBUFF) {
236 send_buffer = strdup ("S2\r\n");
237 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
238 if (result!=STATE_OK)
239 return result;
240 cache_buffers=strtoul(recv_buffer,NULL,10);
242 if (check_critical_value==TRUE && cache_buffers <= critical_value)
243 result=STATE_CRITICAL;
244 else if (check_warning_value==TRUE && cache_buffers <= warning_value)
245 result=STATE_WARNING;
247 asprintf (&output_message,
248 _("%s: Total cache buffers = %lu"),
249 state_text(result),
250 cache_buffers);
252 /* check dirty cache buffers */
253 } else if (vars_to_check==CDBUFF) {
255 send_buffer = strdup ("S3\r\n");
256 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
257 if (result!=STATE_OK)
258 return result;
259 cache_buffers=strtoul(recv_buffer,NULL,10);
261 if (check_critical_value==TRUE && cache_buffers >= critical_value)
262 result=STATE_CRITICAL;
263 else if (check_warning_value==TRUE && cache_buffers >= warning_value)
264 result=STATE_WARNING;
266 asprintf (&output_message,
267 _("%s: Dirty cache buffers = %lu"),
268 state_text(result),
269 cache_buffers);
271 /* check LRU sitting time in minutes */
272 } else if (vars_to_check==LRUM) {
274 send_buffer = strdup ("S5\r\n");
275 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
276 if (result!=STATE_OK)
277 return result;
278 lru_time=strtoul(recv_buffer,NULL,10);
280 if (check_critical_value==TRUE && lru_time <= critical_value)
281 result=STATE_CRITICAL;
282 else if (check_warning_value==TRUE && lru_time <= warning_value)
283 result=STATE_WARNING;
285 asprintf (&output_message,
286 _("%s: LRU sitting time = %lu minutes"),
287 state_text(result),
288 lru_time);
291 /* check KB free space on volume */
292 } else if (vars_to_check==VKF) {
294 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
295 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
296 if (result!=STATE_OK)
297 return result;
299 if (!strcmp(recv_buffer,"-1\n")) {
300 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
301 result=STATE_CRITICAL;
302 } else {
303 free_disk_space=strtoul(recv_buffer,NULL,10);
304 if (check_critical_value==TRUE && free_disk_space <= critical_value)
305 result=STATE_CRITICAL;
306 else if (check_warning_value==TRUE && free_disk_space <= warning_value)
307 result=STATE_WARNING;
308 asprintf (&output_message,
309 _("%s%lu KB free on volume %s"),
310 (result==STATE_OK)?"":_("Only "),
311 free_disk_space,
312 volume_name);
313 }
315 /* check % free space on volume */
316 } else if (vars_to_check==VPF) {
318 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
319 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
320 if (result!=STATE_OK)
321 return result;
323 if (!strcmp(recv_buffer,"-1\n")) {
325 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
326 result=STATE_CRITICAL;
328 } else {
330 free_disk_space=strtoul(recv_buffer,NULL,10);
332 close(sd);
333 my_tcp_connect (server_address, server_port, &sd);
335 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
336 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
337 if (result!=STATE_OK)
338 return result;
339 total_disk_space=strtoul(recv_buffer,NULL,10);
341 percent_free_space=(unsigned long)(((double)free_disk_space/(double)total_disk_space)*100.0);
343 if (check_critical_value==TRUE && percent_free_space <= critical_value)
344 result=STATE_CRITICAL;
345 else if (check_warning_value==TRUE && percent_free_space <= warning_value)
346 result=STATE_WARNING;
347 free_disk_space/=1024;
348 total_disk_space/=1024;
349 asprintf (&output_message,_("%lu MB (%lu%%) free on volume %s - total %lu MB"),free_disk_space,percent_free_space,volume_name,total_disk_space);
350 }
352 /* check to see if DS Database is open or closed */
353 } else if (vars_to_check==DSDB) {
355 send_buffer = strdup ("S11\r\n");
356 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
357 if (result!=STATE_OK)
358 return result;
359 if (atoi(recv_buffer)==1)
360 result=STATE_OK;
361 else
362 result=STATE_WARNING;
364 close(sd);
365 my_tcp_connect (server_address, server_port, &sd);
367 send_buffer = strdup ("S13\r\n");
368 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
369 temp_buffer=strtok(recv_buffer,"\r\n");
371 asprintf (&output_message,_("Directory Services Database is %s (DS version %s)"),(result==STATE_OK)?"open":"closed",temp_buffer);
373 /* check to see if logins are enabled */
374 } else if (vars_to_check==LOGINS) {
376 send_buffer = strdup ("S12\r\n");
377 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
378 if (result!=STATE_OK)
379 return result;
380 if (atoi(recv_buffer)==1)
381 result=STATE_OK;
382 else
383 result=STATE_WARNING;
385 asprintf (&output_message,_("Logins are %s"),(result==STATE_OK)?_("enabled"):_("disabled"));
387 /* check packet receive buffers */
388 } else if (vars_to_check==UPRB || vars_to_check==PUPRB) {
390 asprintf (&send_buffer,"S15\r\n");
391 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
392 if (result!=STATE_OK)
393 return result;
395 used_packet_receive_buffers=atoi(recv_buffer);
397 asprintf (&send_buffer,"S16\r\n");
398 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
399 if (result!=STATE_OK)
400 return result;
402 max_packet_receive_buffers=atoi(recv_buffer);
404 percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
406 if (vars_to_check==UPRB) {
407 if (check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
408 result=STATE_CRITICAL;
409 else if (check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
410 result=STATE_WARNING;
411 } else {
412 if (check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
413 result=STATE_CRITICAL;
414 else if (check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
415 result=STATE_WARNING;
416 }
418 asprintf (&output_message,_("%lu of %lu (%lu%%) packet receive buffers used"),used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
420 /* check SAP table entries */
421 } else if (vars_to_check==SAPENTRIES) {
423 if (sap_number==-1)
424 asprintf (&send_buffer,"S9\r\n");
425 else
426 asprintf (&send_buffer,"S9.%d\r\n",sap_number);
427 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
428 if (result!=STATE_OK)
429 return result;
431 sap_entries=atoi(recv_buffer);
433 if (check_critical_value==TRUE && sap_entries >= critical_value)
434 result=STATE_CRITICAL;
435 else if (check_warning_value==TRUE && sap_entries >= warning_value)
436 result=STATE_WARNING;
438 if (sap_number==-1)
439 asprintf (&output_message,_("%lu entries in SAP table"),sap_entries);
440 else
441 asprintf (&output_message,_("%lu entries in SAP table for SAP type %d"),sap_entries,sap_number);
443 /* check KB purgeable space on volume */
444 } else if (vars_to_check==VKP) {
446 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
447 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
448 if (result!=STATE_OK)
449 return result;
451 if (!strcmp(recv_buffer,"-1\n")) {
452 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
453 result=STATE_CRITICAL;
454 } else {
455 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
456 if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
457 result=STATE_CRITICAL;
458 else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
459 result=STATE_WARNING;
460 asprintf (&output_message,_("%s%lu KB purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),purgeable_disk_space,volume_name);
461 }
463 /* check % purgeable space on volume */
464 } else if (vars_to_check==VPP) {
466 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
467 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
468 if (result!=STATE_OK)
469 return result;
471 if (!strcmp(recv_buffer,"-1\n")) {
473 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
474 result=STATE_CRITICAL;
476 } else {
478 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
480 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
481 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
482 if (result!=STATE_OK)
483 return result;
484 total_disk_space=strtoul(recv_buffer,NULL,10);
486 percent_purgeable_space=(unsigned long)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
488 if (check_critical_value==TRUE && percent_purgeable_space >= critical_value)
489 result=STATE_CRITICAL;
490 else if (check_warning_value==TRUE && percent_purgeable_space >= warning_value)
491 result=STATE_WARNING;
492 purgeable_disk_space/=1024;
493 asprintf (&output_message,_("%lu MB (%lu%%) purgeable on volume %s"),purgeable_disk_space,percent_purgeable_space,volume_name);
494 }
496 /* check KB not yet purgeable space on volume */
497 } else if (vars_to_check==VKNP) {
499 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
500 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
501 if (result!=STATE_OK)
502 return result;
504 if (!strcmp(recv_buffer,"-1\n")) {
505 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
506 result=STATE_CRITICAL;
507 } else {
508 non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
509 if (check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
510 result=STATE_CRITICAL;
511 else if (check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
512 result=STATE_WARNING;
513 asprintf (&output_message,_("%s%lu KB not yet purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),non_purgeable_disk_space,volume_name);
514 }
516 /* check % not yet purgeable space on volume */
517 } else if (vars_to_check==VPNP) {
519 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
520 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
521 if (result!=STATE_OK)
522 return result;
524 if (!strcmp(recv_buffer,"-1\n")) {
526 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
527 result=STATE_CRITICAL;
529 } else {
531 non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
533 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
534 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
535 if (result!=STATE_OK)
536 return result;
537 total_disk_space=strtoul(recv_buffer,NULL,10);
539 percent_non_purgeable_space=(unsigned long)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
541 if (check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
542 result=STATE_CRITICAL;
543 else if (check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
544 result=STATE_WARNING;
545 purgeable_disk_space/=1024;
546 asprintf (&output_message,_("%lu MB (%lu%%) not yet purgeable on volume %s"),non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
547 }
549 /* check # of open files */
550 } else if (vars_to_check==OFILES) {
552 asprintf (&send_buffer,"S18\r\n");
553 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
554 if (result!=STATE_OK)
555 return result;
557 open_files=atoi(recv_buffer);
559 if (check_critical_value==TRUE && open_files >= critical_value)
560 result=STATE_CRITICAL;
561 else if (check_warning_value==TRUE && open_files >= warning_value)
562 result=STATE_WARNING;
564 asprintf (&output_message,_("%lu open files"),open_files);
566 /* check # of abended threads (Netware 5.x only) */
567 } else if (vars_to_check==ABENDS) {
569 asprintf (&send_buffer,"S17\r\n");
570 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
571 if (result!=STATE_OK)
572 return result;
574 abended_threads=atoi(recv_buffer);
576 if (check_critical_value==TRUE && abended_threads >= critical_value)
577 result=STATE_CRITICAL;
578 else if (check_warning_value==TRUE && abended_threads >= warning_value)
579 result=STATE_WARNING;
581 asprintf (&output_message,_("%lu abended threads"),abended_threads);
583 /* check # of current service processes (Netware 5.x only) */
584 } else if (vars_to_check==CSPROCS) {
586 asprintf (&send_buffer,"S20\r\n");
587 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
588 if (result!=STATE_OK)
589 return result;
591 max_service_processes=atoi(recv_buffer);
593 close(sd);
594 my_tcp_connect (server_address, server_port, &sd);
596 asprintf (&send_buffer,"S21\r\n");
597 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
598 if (result!=STATE_OK)
599 return result;
601 current_service_processes=atoi(recv_buffer);
603 if (check_critical_value==TRUE && current_service_processes >= critical_value)
604 result=STATE_CRITICAL;
605 else if (check_warning_value==TRUE && current_service_processes >= warning_value)
606 result=STATE_WARNING;
608 asprintf (&output_message,
609 _("%lu current service processes (%lu max)"),
610 current_service_processes,
611 max_service_processes);
613 /* check # Timesync Status */
614 } else if (vars_to_check==TSYNC) {
616 asprintf (&send_buffer,"S22\r\n");
617 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
618 if (result!=STATE_OK)
619 return result;
621 time_sync_status=atoi(recv_buffer);
623 if (time_sync_status==0) {
624 result=STATE_CRITICAL;
625 asprintf (&output_message,_("CRITICAL - Time not in sync with network!"));
626 }
627 else {
628 asprintf (&output_message,_("OK - Time in sync with network!"));
629 }
631 /* check LRU sitting time in secondss */
632 } else if (vars_to_check==LRUS) {
634 send_buffer = strdup ("S4\r\n");
635 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
636 if (result!=STATE_OK)
637 return result;
638 lru_time=strtoul(recv_buffer,NULL,10);
640 if (check_critical_value==TRUE && lru_time <= critical_value)
641 result=STATE_CRITICAL;
642 else if (check_warning_value==TRUE && lru_time <= warning_value)
643 result=STATE_WARNING;
644 asprintf (&output_message,_("LRU sitting time = %lu seconds"),lru_time);
647 /* check % dirty cacheobuffers as a percentage of the total*/
648 } else if (vars_to_check==DCB) {
650 send_buffer = strdup ("S6\r\n");
651 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
652 if (result!=STATE_OK)
653 return result;
654 dirty_cache_buffers=atoi(recv_buffer);
656 if (check_critical_value==TRUE && dirty_cache_buffers <= critical_value)
657 result=STATE_CRITICAL;
658 else if (check_warning_value==TRUE && dirty_cache_buffers <= warning_value)
659 result=STATE_WARNING;
660 asprintf (&output_message,_("Dirty cache buffers = %lu%% of the total"),dirty_cache_buffers);
662 /* check % total cache buffers as a percentage of the original*/
663 } else if (vars_to_check==TCB) {
665 send_buffer = strdup ("S7\r\n");
666 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
667 if (result!=STATE_OK)
668 return result;
669 total_cache_buffers=atoi(recv_buffer);
671 if (check_critical_value==TRUE && total_cache_buffers <= critical_value)
672 result=STATE_CRITICAL;
673 else if (check_warning_value==TRUE && total_cache_buffers <= warning_value)
674 result=STATE_WARNING;
675 asprintf (&output_message,_("Total cache buffers = %lu%% of the original"),total_cache_buffers);
677 } else if (vars_to_check==DSVER) {
678 asprintf (&send_buffer,"S13\r\n");
679 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
680 if (result!=STATE_OK)
681 return result;
683 recv_buffer[strlen(recv_buffer)-1]=0;
685 asprintf (&output_message,_("NDS Version %s"),recv_buffer);
687 } else if (vars_to_check==UPTIME) {
688 asprintf (&send_buffer,"UPTIME\r\n");
689 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
690 if (result!=STATE_OK)
691 return result;
694 recv_buffer[sizeof(recv_buffer)-1]=0;
695 recv_buffer[strlen(recv_buffer)-1]=0;
697 asprintf (&output_message,_("Up %s"),recv_buffer);
699 } else if (vars_to_check==NLM) {
700 asprintf (&send_buffer,"S24:%s\r\n",nlm_name);
701 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
702 if (result!=STATE_OK)
703 return result;
705 recv_buffer[strlen(recv_buffer)-1]=0;
706 if (strcmp(recv_buffer,"-1")) {
707 asprintf (&output_message,_("Module %s version %s is loaded"),nlm_name,recv_buffer);
708 } else {
709 result=STATE_CRITICAL;
710 asprintf (&output_message,_("Module %s is not loaded"),nlm_name);
711 }
713 } else {
715 output_message = strdup (_("Nothing to check!\n"));
716 result=STATE_UNKNOWN;
718 }
720 close (sd);
722 /* reset timeout */
723 alarm(0);
725 printf("%s%s\n",netware_version,output_message);
727 return result;
728 }
732 /* process command-line arguments */
733 int process_arguments(int argc, char **argv) {
734 int c;
736 int option = 0;
737 static struct option longopts[] =
738 {
739 {"port", required_argument,0,'p'},
740 {"timeout", required_argument,0,'t'},
741 {"critical", required_argument,0,'c'},
742 {"warning", required_argument,0,'w'},
743 {"variable", required_argument,0,'v'},
744 {"hostname", required_argument,0,'H'},
745 {"osversion",no_argument, 0,'o'},
746 {"version", no_argument, 0,'V'},
747 {"help", no_argument, 0,'h'},
748 {0,0,0,0}
749 };
751 /* no options were supplied */
752 if (argc<2) return ERROR;
754 /* backwards compatibility */
755 if (! is_option(argv[1])) {
756 server_address=argv[1];
757 argv[1]=argv[0];
758 argv=&argv[1];
759 argc--;
760 }
762 for (c=1;c<argc;c++) {
763 if (strcmp("-to",argv[c])==0)
764 strcpy(argv[c],"-t");
765 else if (strcmp("-wv",argv[c])==0)
766 strcpy(argv[c],"-w");
767 else if (strcmp("-cv",argv[c])==0)
768 strcpy(argv[c],"-c");
769 }
771 while (1) {
772 c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",longopts,&option);
774 if (c==-1||c==EOF||c==1)
775 break;
777 switch (c)
778 {
779 case '?': /* print short usage statement if args not parsable */
780 usage2 (_("Unknown argument"), optarg);
781 case 'h': /* help */
782 print_help();
783 exit(STATE_OK);
784 case 'V': /* version */
785 print_revision(progname, revision);
786 exit(STATE_OK);
787 case 'H': /* hostname */
788 server_address=optarg;
789 break;
790 case 'o': /* display nos version */
791 check_netware_version=TRUE;
792 break;
793 case 'p': /* port */
794 if (is_intnonneg(optarg))
795 server_port=atoi(optarg);
796 else
797 die(STATE_UNKNOWN,_("Server port an integer\n"));
798 break;
799 case 'v':
800 if (strlen(optarg)<3)
801 return ERROR;
802 if (!strcmp(optarg,"LOAD1"))
803 vars_to_check=LOAD1;
804 else if (!strcmp(optarg,"LOAD5"))
805 vars_to_check=LOAD5;
806 else if (!strcmp(optarg,"LOAD15"))
807 vars_to_check=LOAD15;
808 else if (!strcmp(optarg,"CONNS"))
809 vars_to_check=CONNS;
810 else if (!strcmp(optarg,"LTCH"))
811 vars_to_check=LTCH;
812 else if (!strcmp(optarg,"DCB"))
813 vars_to_check=DCB;
814 else if (!strcmp(optarg,"TCB"))
815 vars_to_check=TCB;
816 else if (!strcmp(optarg,"CBUFF"))
817 vars_to_check=CBUFF;
818 else if (!strcmp(optarg,"CDBUFF"))
819 vars_to_check=CDBUFF;
820 else if (!strcmp(optarg,"LRUM"))
821 vars_to_check=LRUM;
822 else if (!strcmp(optarg,"LRUS"))
823 vars_to_check=LRUS;
824 else if (strncmp(optarg,"VPF",3)==0) {
825 vars_to_check=VPF;
826 volume_name = strdup (optarg+3);
827 if (!strcmp(volume_name,""))
828 volume_name = strdup ("SYS");
829 }
830 else if (strncmp(optarg,"VKF",3)==0) {
831 vars_to_check=VKF;
832 volume_name = strdup (optarg+3);
833 if (!strcmp(volume_name,""))
834 volume_name = strdup ("SYS");
835 }
836 else if (!strcmp(optarg,"DSDB"))
837 vars_to_check=DSDB;
838 else if (!strcmp(optarg,"LOGINS"))
839 vars_to_check=LOGINS;
840 else if (!strcmp(optarg,"UPRB"))
841 vars_to_check=UPRB;
842 else if (!strcmp(optarg,"PUPRB"))
843 vars_to_check=PUPRB;
844 else if (!strncmp(optarg,"SAPENTRIES",10)) {
845 vars_to_check=SAPENTRIES;
846 if (strlen(optarg)>10)
847 sap_number=atoi(optarg+10);
848 else
849 sap_number=-1;
850 }
851 else if (!strcmp(optarg,"OFILES"))
852 vars_to_check=OFILES;
853 else if (strncmp(optarg,"VKP",3)==0) {
854 vars_to_check=VKP;
855 volume_name = strdup (optarg+3);
856 if (!strcmp(volume_name,""))
857 volume_name = strdup ("SYS");
858 }
859 else if (strncmp(optarg,"VPP",3)==0) {
860 vars_to_check=VPP;
861 volume_name = strdup (optarg+3);
862 if (!strcmp(volume_name,""))
863 volume_name = strdup ("SYS");
864 }
865 else if (strncmp(optarg,"VKNP",4)==0) {
866 vars_to_check=VKNP;
867 volume_name = strdup (optarg+4);
868 if (!strcmp(volume_name,""))
869 volume_name = strdup ("SYS");
870 }
871 else if (strncmp(optarg,"VPNP",4)==0) {
872 vars_to_check=VPNP;
873 volume_name = strdup (optarg+4);
874 if (!strcmp(volume_name,""))
875 volume_name = strdup("SYS");
876 }
877 else if (!strcmp(optarg,"ABENDS"))
878 vars_to_check=ABENDS;
879 else if (!strcmp(optarg,"CSPROCS"))
880 vars_to_check=CSPROCS;
881 else if (!strcmp(optarg,"TSYNC"))
882 vars_to_check=TSYNC;
883 else if (!strcmp(optarg,"DSVER"))
884 vars_to_check=DSVER;
885 else if (!strcmp(optarg,"UPTIME")) {
886 vars_to_check=UPTIME;
887 }
888 else if (strncmp(optarg,"NLM:",4)==0) {
889 vars_to_check=NLM;
890 nlm_name=strdup (optarg+4);
891 }
892 else
893 return ERROR;
894 break;
895 case 'w': /* warning threshold */
896 warning_value=strtoul(optarg,NULL,10);
897 check_warning_value=TRUE;
898 break;
899 case 'c': /* critical threshold */
900 critical_value=strtoul(optarg,NULL,10);
901 check_critical_value=TRUE;
902 break;
903 case 't': /* timeout */
904 socket_timeout=atoi(optarg);
905 if (socket_timeout<=0)
906 return ERROR;
907 }
909 }
911 return OK;
912 }
916 void print_help(void)
917 {
918 char *myport;
919 asprintf (&myport, "%d", PORT);
921 print_revision (progname, revision);
923 printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
924 printf (COPYRIGHT, copyright, email);
926 printf (_("\
927 This plugin attempts to contact the MRTGEXT NLM running on a\n\
928 Novell server to gather the requested system information.\n\n"));
930 print_usage();
932 printf (_(UT_HELP_VRSN));
934 printf (_(UT_HOST_PORT), 'p', myport);
936 printf (_("\
937 -v, --variable=STRING\n\
938 Variable to check. Valid variables include:\n\
939 LOAD1 = 1 minute average CPU load\n\
940 LOAD5 = 5 minute average CPU load\n\
941 LOAD15 = 15 minute average CPU load\n\
942 CSPROCS = number of current service processes (NW 5.x only)\n\
943 ABENDS = number of abended threads (NW 5.x only)\n\
944 UPTIME = server uptime\n"));
946 printf (_("\
947 LTCH = percent long term cache hits\n\
948 CBUFF = current number of cache buffers\n\
949 CDBUFF = current number of dirty cache buffers\n\
950 DCB = dirty cache buffers as a percentage of the total\n\
951 TCB = dirty cache buffers as a percentage of the original\n"));
953 printf (_("\
954 OFILES = number of open files\n\
955 VPF<vol> = percent free space on volume <vol>\n\
956 VKF<vol> = KB of free space on volume <vol>\n\
957 VPP<vol> = percent purgeable space on volume <vol>\n\
958 VKP<vol> = KB of purgeable space on volume <vol>\n\
959 VPNP<vol> = percent not yet purgeable space on volume <vol>\n\
960 VKNP<vol> = KB of not yet purgeable space on volume <vol>\n"));
962 printf (_("\
963 LRUM = LRU sitting time in minutes\n\
964 LRUS = LRU sitting time in seconds\n\
965 DSDB = check to see if DS Database is open\n\
966 DSVER = NDS version\n\
967 UPRB = used packet receive buffers\n\
968 PUPRB = percent (of max) used packet receive buffers\n\
969 SAPENTRIES = number of entries in the SAP table\n\
970 SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>\n"));
972 printf (_("\
973 TSYNC = timesync status \n\
974 LOGINS = check to see if logins are enabled\n\
975 CONNS = number of currently licensed connections\n\
976 NLM:<nlm> = check if NLM is loaded and report version\n\
977 (e.g. \"NLM:TSANDS.NLM\")\n"));
979 printf (_("\
980 -w, --warning=INTEGER\n\
981 Threshold which will result in a warning status\n\
982 -c, --critical=INTEGER\n\
983 Threshold which will result in a critical status\n\
984 -o, --osversion\n\
985 Include server version string in results\n"));
987 printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
989 printf (_("\n\
990 Notes:\n\
991 - This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG\n\
992 extension for NetWare be loaded on the Novell servers you wish to check.\n\
993 (available from http://www.engr.wisc.edu/~drews/mrtg/)\n\
994 - Values for critical thresholds should be lower than warning thresholds\n\
995 when the following variables are checked: VPF, VKF, LTCH, CBUFF, DCB, \n\
996 TCB, LRUS and LRUM.\n"));
998 printf (_(UT_SUPPORT));
999 }
1003 void print_usage(void)
1004 {
1005 printf ("\
1006 Usage: %s -H host [-p port] [-v variable] [-w warning] [-c critical]\n\
1007 [-t timeout].\n", progname);
1008 }