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-2006";
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 close(sd);
168 my_tcp_connect (server_address, server_port, &sd);
170 asprintf (&send_buffer,"UTIL%s\r\n",temp_buffer);
171 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
172 if (result!=STATE_OK)
173 return result;
174 utilization=strtoul(recv_buffer,NULL,10);
176 close(sd);
177 my_tcp_connect (server_address, server_port, &sd);
179 send_buffer = strdup ("UPTIME\r\n");
180 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
181 if (result!=STATE_OK)
182 return result;
183 recv_buffer[strlen(recv_buffer)-1]=0;
184 sprintf(uptime,_("Up %s,"),recv_buffer);
186 if (check_critical_value==TRUE && utilization >= critical_value)
187 result=STATE_CRITICAL;
188 else if (check_warning_value==TRUE && utilization >= warning_value)
189 result=STATE_WARNING;
191 asprintf (&output_message,
192 _("Load %s - %s %s-min load average = %lu%%"),
193 state_text(result),
194 uptime,
195 temp_buffer,
196 utilization);
198 /* check number of user connections */
199 } else if (vars_to_check==CONNS) {
201 close(sd);
202 my_tcp_connect (server_address, server_port, &sd);
204 send_buffer = strdup ("CONNECT\r\n");
205 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
206 if (result!=STATE_OK)
207 return result;
208 current_connections=strtoul(recv_buffer,NULL,10);
210 if (check_critical_value==TRUE && current_connections >= critical_value)
211 result=STATE_CRITICAL;
212 else if (check_warning_value==TRUE && current_connections >= warning_value)
213 result=STATE_WARNING;
215 asprintf (&output_message,
216 _("Conns %s - %lu current connections"),
217 state_text(result),
218 current_connections);
220 /* check % long term cache hits */
221 } else if (vars_to_check==LTCH) {
223 close(sd);
224 my_tcp_connect (server_address, server_port, &sd);
226 send_buffer = strdup ("S1\r\n");
227 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
228 if (result!=STATE_OK)
229 return result;
230 cache_hits=atoi(recv_buffer);
232 if (check_critical_value==TRUE && cache_hits <= critical_value)
233 result=STATE_CRITICAL;
234 else if (check_warning_value==TRUE && cache_hits <= warning_value)
235 result=STATE_WARNING;
237 asprintf (&output_message,
238 _("%s: Long term cache hits = %lu%%"),
239 state_text(result),
240 cache_hits);
242 /* check cache buffers */
243 } else if (vars_to_check==CBUFF) {
245 close(sd);
246 my_tcp_connect (server_address, server_port, &sd);
248 send_buffer = strdup ("S2\r\n");
249 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
250 if (result!=STATE_OK)
251 return result;
252 cache_buffers=strtoul(recv_buffer,NULL,10);
254 if (check_critical_value==TRUE && cache_buffers <= critical_value)
255 result=STATE_CRITICAL;
256 else if (check_warning_value==TRUE && cache_buffers <= warning_value)
257 result=STATE_WARNING;
259 asprintf (&output_message,
260 _("%s: Total cache buffers = %lu"),
261 state_text(result),
262 cache_buffers);
264 /* check dirty cache buffers */
265 } else if (vars_to_check==CDBUFF) {
267 close(sd);
268 my_tcp_connect (server_address, server_port, &sd);
270 send_buffer = strdup ("S3\r\n");
271 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
272 if (result!=STATE_OK)
273 return result;
274 cache_buffers=strtoul(recv_buffer,NULL,10);
276 if (check_critical_value==TRUE && cache_buffers >= critical_value)
277 result=STATE_CRITICAL;
278 else if (check_warning_value==TRUE && cache_buffers >= warning_value)
279 result=STATE_WARNING;
281 asprintf (&output_message,
282 _("%s: Dirty cache buffers = %lu"),
283 state_text(result),
284 cache_buffers);
286 /* check LRU sitting time in minutes */
287 } else if (vars_to_check==LRUM) {
289 close(sd);
290 my_tcp_connect (server_address, server_port, &sd);
292 send_buffer = strdup ("S5\r\n");
293 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
294 if (result!=STATE_OK)
295 return result;
296 lru_time=strtoul(recv_buffer,NULL,10);
298 if (check_critical_value==TRUE && lru_time <= critical_value)
299 result=STATE_CRITICAL;
300 else if (check_warning_value==TRUE && lru_time <= warning_value)
301 result=STATE_WARNING;
303 asprintf (&output_message,
304 _("%s: LRU sitting time = %lu minutes"),
305 state_text(result),
306 lru_time);
309 /* check KB free space on volume */
310 } else if (vars_to_check==VKF) {
312 close(sd);
313 my_tcp_connect (server_address, server_port, &sd);
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")) {
321 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
322 result=STATE_CRITICAL;
323 } else {
324 free_disk_space=strtoul(recv_buffer,NULL,10);
325 if (check_critical_value==TRUE && free_disk_space <= critical_value)
326 result=STATE_CRITICAL;
327 else if (check_warning_value==TRUE && free_disk_space <= warning_value)
328 result=STATE_WARNING;
329 asprintf (&output_message,
330 _("%s%lu KB free on volume %s"),
331 (result==STATE_OK)?"":_("Only "),
332 free_disk_space,
333 volume_name);
334 }
336 /* check % free space on volume */
337 } else if (vars_to_check==VPF) {
339 close(sd);
340 my_tcp_connect (server_address, server_port, &sd);
342 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
343 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
344 if (result!=STATE_OK)
345 return result;
347 if (!strcmp(recv_buffer,"-1\n")) {
349 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
350 result=STATE_CRITICAL;
352 } else {
354 free_disk_space=strtoul(recv_buffer,NULL,10);
356 close(sd);
357 my_tcp_connect (server_address, server_port, &sd);
359 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
360 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
361 if (result!=STATE_OK)
362 return result;
363 total_disk_space=strtoul(recv_buffer,NULL,10);
365 percent_free_space=(unsigned long)(((double)free_disk_space/(double)total_disk_space)*100.0);
367 if (check_critical_value==TRUE && percent_free_space <= critical_value)
368 result=STATE_CRITICAL;
369 else if (check_warning_value==TRUE && percent_free_space <= warning_value)
370 result=STATE_WARNING;
371 free_disk_space/=1024;
372 total_disk_space/=1024;
373 asprintf (&output_message,_("%lu MB (%lu%%) free on volume %s - total %lu MB"),free_disk_space,percent_free_space,volume_name,total_disk_space);
374 }
376 /* check to see if DS Database is open or closed */
377 } else if (vars_to_check==DSDB) {
379 close(sd);
380 my_tcp_connect (server_address, server_port, &sd);
382 send_buffer = strdup ("S11\r\n");
383 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
384 if (result!=STATE_OK)
385 return result;
386 if (atoi(recv_buffer)==1)
387 result=STATE_OK;
388 else
389 result=STATE_WARNING;
391 close(sd);
392 my_tcp_connect (server_address, server_port, &sd);
394 send_buffer = strdup ("S13\r\n");
395 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
396 temp_buffer=strtok(recv_buffer,"\r\n");
398 asprintf (&output_message,_("Directory Services Database is %s (DS version %s)"),(result==STATE_OK)?"open":"closed",temp_buffer);
400 /* check to see if logins are enabled */
401 } else if (vars_to_check==LOGINS) {
403 close(sd);
404 my_tcp_connect (server_address, server_port, &sd);
406 send_buffer = strdup ("S12\r\n");
407 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
408 if (result!=STATE_OK)
409 return result;
410 if (atoi(recv_buffer)==1)
411 result=STATE_OK;
412 else
413 result=STATE_WARNING;
415 asprintf (&output_message,_("Logins are %s"),(result==STATE_OK)?_("enabled"):_("disabled"));
417 /* check packet receive buffers */
418 } else if (vars_to_check==UPRB || vars_to_check==PUPRB) {
420 close(sd);
421 my_tcp_connect (server_address, server_port, &sd);
423 asprintf (&send_buffer,"S15\r\n");
424 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
425 if (result!=STATE_OK)
426 return result;
428 used_packet_receive_buffers=atoi(recv_buffer);
430 close(sd);
431 my_tcp_connect (server_address, server_port, &sd);
433 asprintf (&send_buffer,"S16\r\n");
434 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
435 if (result!=STATE_OK)
436 return result;
438 max_packet_receive_buffers=atoi(recv_buffer);
440 percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
442 if (vars_to_check==UPRB) {
443 if (check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
444 result=STATE_CRITICAL;
445 else if (check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
446 result=STATE_WARNING;
447 } else {
448 if (check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
449 result=STATE_CRITICAL;
450 else if (check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
451 result=STATE_WARNING;
452 }
454 asprintf (&output_message,_("%lu of %lu (%lu%%) packet receive buffers used"),used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
456 /* check SAP table entries */
457 } else if (vars_to_check==SAPENTRIES) {
459 close(sd);
460 my_tcp_connect (server_address, server_port, &sd);
462 if (sap_number==-1)
463 asprintf (&send_buffer,"S9\r\n");
464 else
465 asprintf (&send_buffer,"S9.%d\r\n",sap_number);
466 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
467 if (result!=STATE_OK)
468 return result;
470 sap_entries=atoi(recv_buffer);
472 if (check_critical_value==TRUE && sap_entries >= critical_value)
473 result=STATE_CRITICAL;
474 else if (check_warning_value==TRUE && sap_entries >= warning_value)
475 result=STATE_WARNING;
477 if (sap_number==-1)
478 asprintf (&output_message,_("%lu entries in SAP table"),sap_entries);
479 else
480 asprintf (&output_message,_("%lu entries in SAP table for SAP type %d"),sap_entries,sap_number);
482 /* check KB purgeable space on volume */
483 } else if (vars_to_check==VKP) {
485 close(sd);
486 my_tcp_connect (server_address, server_port, &sd);
488 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
489 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
490 if (result!=STATE_OK)
491 return result;
493 if (!strcmp(recv_buffer,"-1\n")) {
494 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
495 result=STATE_CRITICAL;
496 } else {
497 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
498 if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
499 result=STATE_CRITICAL;
500 else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
501 result=STATE_WARNING;
502 asprintf (&output_message,_("%s%lu KB purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),purgeable_disk_space,volume_name);
503 }
505 /* check % purgeable space on volume */
506 } else if (vars_to_check==VPP) {
508 close(sd);
509 my_tcp_connect (server_address, server_port, &sd);
511 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
512 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
513 if (result!=STATE_OK)
514 return result;
516 if (!strcmp(recv_buffer,"-1\n")) {
518 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
519 result=STATE_CRITICAL;
521 } else {
523 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
525 close(sd);
526 my_tcp_connect (server_address, server_port, &sd);
528 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
529 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
530 if (result!=STATE_OK)
531 return result;
532 total_disk_space=strtoul(recv_buffer,NULL,10);
534 percent_purgeable_space=(unsigned long)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
536 if (check_critical_value==TRUE && percent_purgeable_space >= critical_value)
537 result=STATE_CRITICAL;
538 else if (check_warning_value==TRUE && percent_purgeable_space >= warning_value)
539 result=STATE_WARNING;
540 purgeable_disk_space/=1024;
541 asprintf (&output_message,_("%lu MB (%lu%%) purgeable on volume %s"),purgeable_disk_space,percent_purgeable_space,volume_name);
542 }
544 /* check KB not yet purgeable space on volume */
545 } else if (vars_to_check==VKNP) {
547 close(sd);
548 my_tcp_connect (server_address, server_port, &sd);
550 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
551 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
552 if (result!=STATE_OK)
553 return result;
555 if (!strcmp(recv_buffer,"-1\n")) {
556 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
557 result=STATE_CRITICAL;
558 } else {
559 non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
560 if (check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
561 result=STATE_CRITICAL;
562 else if (check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
563 result=STATE_WARNING;
564 asprintf (&output_message,_("%s%lu KB not yet purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),non_purgeable_disk_space,volume_name);
565 }
567 /* check % not yet purgeable space on volume */
568 } else if (vars_to_check==VPNP) {
570 close(sd);
571 my_tcp_connect (server_address, server_port, &sd);
573 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
574 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
575 if (result!=STATE_OK)
576 return result;
578 if (!strcmp(recv_buffer,"-1\n")) {
580 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
581 result=STATE_CRITICAL;
583 } else {
585 non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
587 close(sd);
588 my_tcp_connect (server_address, server_port, &sd);
590 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
591 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
592 if (result!=STATE_OK)
593 return result;
594 total_disk_space=strtoul(recv_buffer,NULL,10);
596 percent_non_purgeable_space=(unsigned long)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
598 if (check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
599 result=STATE_CRITICAL;
600 else if (check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
601 result=STATE_WARNING;
602 purgeable_disk_space/=1024;
603 asprintf (&output_message,_("%lu MB (%lu%%) not yet purgeable on volume %s"),non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
604 }
606 /* check # of open files */
607 } else if (vars_to_check==OFILES) {
609 close(sd);
610 my_tcp_connect (server_address, server_port, &sd);
612 asprintf (&send_buffer,"S18\r\n");
613 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
614 if (result!=STATE_OK)
615 return result;
617 open_files=atoi(recv_buffer);
619 if (check_critical_value==TRUE && open_files >= critical_value)
620 result=STATE_CRITICAL;
621 else if (check_warning_value==TRUE && open_files >= warning_value)
622 result=STATE_WARNING;
624 asprintf (&output_message,_("%lu open files"),open_files);
626 /* check # of abended threads (Netware 5.x only) */
627 } else if (vars_to_check==ABENDS) {
629 close(sd);
630 my_tcp_connect (server_address, server_port, &sd);
632 asprintf (&send_buffer,"S17\r\n");
633 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
634 if (result!=STATE_OK)
635 return result;
637 abended_threads=atoi(recv_buffer);
639 if (check_critical_value==TRUE && abended_threads >= critical_value)
640 result=STATE_CRITICAL;
641 else if (check_warning_value==TRUE && abended_threads >= warning_value)
642 result=STATE_WARNING;
644 asprintf (&output_message,_("%lu abended threads"),abended_threads);
646 /* check # of current service processes (Netware 5.x only) */
647 } else if (vars_to_check==CSPROCS) {
649 close(sd);
650 my_tcp_connect (server_address, server_port, &sd);
652 asprintf (&send_buffer,"S20\r\n");
653 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
654 if (result!=STATE_OK)
655 return result;
657 max_service_processes=atoi(recv_buffer);
659 close(sd);
660 my_tcp_connect (server_address, server_port, &sd);
662 asprintf (&send_buffer,"S21\r\n");
663 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
664 if (result!=STATE_OK)
665 return result;
667 current_service_processes=atoi(recv_buffer);
669 if (check_critical_value==TRUE && current_service_processes >= critical_value)
670 result=STATE_CRITICAL;
671 else if (check_warning_value==TRUE && current_service_processes >= warning_value)
672 result=STATE_WARNING;
674 asprintf (&output_message,
675 _("%lu current service processes (%lu max)"),
676 current_service_processes,
677 max_service_processes);
679 /* check # Timesync Status */
680 } else if (vars_to_check==TSYNC) {
682 close(sd);
683 my_tcp_connect (server_address, server_port, &sd);
685 asprintf (&send_buffer,"S22\r\n");
686 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
687 if (result!=STATE_OK)
688 return result;
690 time_sync_status=atoi(recv_buffer);
692 if (time_sync_status==0) {
693 result=STATE_CRITICAL;
694 asprintf (&output_message,_("CRITICAL - Time not in sync with network!"));
695 }
696 else {
697 asprintf (&output_message,_("OK - Time in sync with network!"));
698 }
700 /* check LRU sitting time in secondss */
701 } else if (vars_to_check==LRUS) {
703 close(sd);
704 my_tcp_connect (server_address, server_port, &sd);
706 send_buffer = strdup ("S4\r\n");
707 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
708 if (result!=STATE_OK)
709 return result;
710 lru_time=strtoul(recv_buffer,NULL,10);
712 if (check_critical_value==TRUE && lru_time <= critical_value)
713 result=STATE_CRITICAL;
714 else if (check_warning_value==TRUE && lru_time <= warning_value)
715 result=STATE_WARNING;
716 asprintf (&output_message,_("LRU sitting time = %lu seconds"),lru_time);
719 /* check % dirty cacheobuffers as a percentage of the total*/
720 } else if (vars_to_check==DCB) {
722 close(sd);
723 my_tcp_connect (server_address, server_port, &sd);
725 send_buffer = strdup ("S6\r\n");
726 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
727 if (result!=STATE_OK)
728 return result;
729 dirty_cache_buffers=atoi(recv_buffer);
731 if (check_critical_value==TRUE && dirty_cache_buffers <= critical_value)
732 result=STATE_CRITICAL;
733 else if (check_warning_value==TRUE && dirty_cache_buffers <= warning_value)
734 result=STATE_WARNING;
735 asprintf (&output_message,_("Dirty cache buffers = %lu%% of the total"),dirty_cache_buffers);
737 /* check % total cache buffers as a percentage of the original*/
738 } else if (vars_to_check==TCB) {
740 close(sd);
741 my_tcp_connect (server_address, server_port, &sd);
743 send_buffer = strdup ("S7\r\n");
744 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
745 if (result!=STATE_OK)
746 return result;
747 total_cache_buffers=atoi(recv_buffer);
749 if (check_critical_value==TRUE && total_cache_buffers <= critical_value)
750 result=STATE_CRITICAL;
751 else if (check_warning_value==TRUE && total_cache_buffers <= warning_value)
752 result=STATE_WARNING;
753 asprintf (&output_message,_("Total cache buffers = %lu%% of the original"),total_cache_buffers);
755 } else if (vars_to_check==DSVER) {
757 close(sd);
758 my_tcp_connect (server_address, server_port, &sd);
760 asprintf (&send_buffer,"S13\r\n");
761 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
762 if (result!=STATE_OK)
763 return result;
765 recv_buffer[strlen(recv_buffer)-1]=0;
767 asprintf (&output_message,_("NDS Version %s"),recv_buffer);
769 } else if (vars_to_check==UPTIME) {
771 close(sd);
772 my_tcp_connect (server_address, server_port, &sd);
774 asprintf (&send_buffer,"UPTIME\r\n");
775 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
776 if (result!=STATE_OK)
777 return result;
780 recv_buffer[sizeof(recv_buffer)-1]=0;
781 recv_buffer[strlen(recv_buffer)-1]=0;
783 asprintf (&output_message,_("Up %s"),recv_buffer);
785 } else if (vars_to_check==NLM) {
787 close(sd);
788 my_tcp_connect (server_address, server_port, &sd);
790 asprintf (&send_buffer,"S24:%s\r\n",nlm_name);
791 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
792 if (result!=STATE_OK)
793 return result;
795 recv_buffer[strlen(recv_buffer)-1]=0;
796 if (strcmp(recv_buffer,"-1")) {
797 asprintf (&output_message,_("Module %s version %s is loaded"),nlm_name,recv_buffer);
798 } else {
799 result=STATE_CRITICAL;
800 asprintf (&output_message,_("Module %s is not loaded"),nlm_name);
801 }
803 } else {
805 output_message = strdup (_("Nothing to check!\n"));
806 result=STATE_UNKNOWN;
808 }
810 close (sd);
812 /* reset timeout */
813 alarm(0);
815 printf("%s%s\n",netware_version,output_message);
817 return result;
818 }
822 /* process command-line arguments */
823 int process_arguments(int argc, char **argv) {
824 int c;
826 int option = 0;
827 static struct option longopts[] =
828 {
829 {"port", required_argument,0,'p'},
830 {"timeout", required_argument,0,'t'},
831 {"critical", required_argument,0,'c'},
832 {"warning", required_argument,0,'w'},
833 {"variable", required_argument,0,'v'},
834 {"hostname", required_argument,0,'H'},
835 {"osversion",no_argument, 0,'o'},
836 {"version", no_argument, 0,'V'},
837 {"help", no_argument, 0,'h'},
838 {0,0,0,0}
839 };
841 /* no options were supplied */
842 if (argc<2) return ERROR;
844 /* backwards compatibility */
845 if (! is_option(argv[1])) {
846 server_address=argv[1];
847 argv[1]=argv[0];
848 argv=&argv[1];
849 argc--;
850 }
852 for (c=1;c<argc;c++) {
853 if (strcmp("-to",argv[c])==0)
854 strcpy(argv[c],"-t");
855 else if (strcmp("-wv",argv[c])==0)
856 strcpy(argv[c],"-w");
857 else if (strcmp("-cv",argv[c])==0)
858 strcpy(argv[c],"-c");
859 }
861 while (1) {
862 c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",longopts,&option);
864 if (c==-1||c==EOF||c==1)
865 break;
867 switch (c)
868 {
869 case '?': /* print short usage statement if args not parsable */
870 usage2 (_("Unknown argument"), optarg);
871 case 'h': /* help */
872 print_help();
873 exit(STATE_OK);
874 case 'V': /* version */
875 print_revision(progname, revision);
876 exit(STATE_OK);
877 case 'H': /* hostname */
878 server_address=optarg;
879 break;
880 case 'o': /* display nos version */
881 check_netware_version=TRUE;
882 break;
883 case 'p': /* port */
884 if (is_intnonneg(optarg))
885 server_port=atoi(optarg);
886 else
887 die(STATE_UNKNOWN,_("Server port an integer\n"));
888 break;
889 case 'v':
890 if (strlen(optarg)<3)
891 return ERROR;
892 if (!strcmp(optarg,"LOAD1"))
893 vars_to_check=LOAD1;
894 else if (!strcmp(optarg,"LOAD5"))
895 vars_to_check=LOAD5;
896 else if (!strcmp(optarg,"LOAD15"))
897 vars_to_check=LOAD15;
898 else if (!strcmp(optarg,"CONNS"))
899 vars_to_check=CONNS;
900 else if (!strcmp(optarg,"LTCH"))
901 vars_to_check=LTCH;
902 else if (!strcmp(optarg,"DCB"))
903 vars_to_check=DCB;
904 else if (!strcmp(optarg,"TCB"))
905 vars_to_check=TCB;
906 else if (!strcmp(optarg,"CBUFF"))
907 vars_to_check=CBUFF;
908 else if (!strcmp(optarg,"CDBUFF"))
909 vars_to_check=CDBUFF;
910 else if (!strcmp(optarg,"LRUM"))
911 vars_to_check=LRUM;
912 else if (!strcmp(optarg,"LRUS"))
913 vars_to_check=LRUS;
914 else if (strncmp(optarg,"VPF",3)==0) {
915 vars_to_check=VPF;
916 volume_name = strdup (optarg+3);
917 if (!strcmp(volume_name,""))
918 volume_name = strdup ("SYS");
919 }
920 else if (strncmp(optarg,"VKF",3)==0) {
921 vars_to_check=VKF;
922 volume_name = strdup (optarg+3);
923 if (!strcmp(volume_name,""))
924 volume_name = strdup ("SYS");
925 }
926 else if (!strcmp(optarg,"DSDB"))
927 vars_to_check=DSDB;
928 else if (!strcmp(optarg,"LOGINS"))
929 vars_to_check=LOGINS;
930 else if (!strcmp(optarg,"UPRB"))
931 vars_to_check=UPRB;
932 else if (!strcmp(optarg,"PUPRB"))
933 vars_to_check=PUPRB;
934 else if (!strncmp(optarg,"SAPENTRIES",10)) {
935 vars_to_check=SAPENTRIES;
936 if (strlen(optarg)>10)
937 sap_number=atoi(optarg+10);
938 else
939 sap_number=-1;
940 }
941 else if (!strcmp(optarg,"OFILES"))
942 vars_to_check=OFILES;
943 else if (strncmp(optarg,"VKP",3)==0) {
944 vars_to_check=VKP;
945 volume_name = strdup (optarg+3);
946 if (!strcmp(volume_name,""))
947 volume_name = strdup ("SYS");
948 }
949 else if (strncmp(optarg,"VPP",3)==0) {
950 vars_to_check=VPP;
951 volume_name = strdup (optarg+3);
952 if (!strcmp(volume_name,""))
953 volume_name = strdup ("SYS");
954 }
955 else if (strncmp(optarg,"VKNP",4)==0) {
956 vars_to_check=VKNP;
957 volume_name = strdup (optarg+4);
958 if (!strcmp(volume_name,""))
959 volume_name = strdup ("SYS");
960 }
961 else if (strncmp(optarg,"VPNP",4)==0) {
962 vars_to_check=VPNP;
963 volume_name = strdup (optarg+4);
964 if (!strcmp(volume_name,""))
965 volume_name = strdup("SYS");
966 }
967 else if (!strcmp(optarg,"ABENDS"))
968 vars_to_check=ABENDS;
969 else if (!strcmp(optarg,"CSPROCS"))
970 vars_to_check=CSPROCS;
971 else if (!strcmp(optarg,"TSYNC"))
972 vars_to_check=TSYNC;
973 else if (!strcmp(optarg,"DSVER"))
974 vars_to_check=DSVER;
975 else if (!strcmp(optarg,"UPTIME")) {
976 vars_to_check=UPTIME;
977 }
978 else if (strncmp(optarg,"NLM:",4)==0) {
979 vars_to_check=NLM;
980 nlm_name=strdup (optarg+4);
981 }
982 else
983 return ERROR;
984 break;
985 case 'w': /* warning threshold */
986 warning_value=strtoul(optarg,NULL,10);
987 check_warning_value=TRUE;
988 break;
989 case 'c': /* critical threshold */
990 critical_value=strtoul(optarg,NULL,10);
991 check_critical_value=TRUE;
992 break;
993 case 't': /* timeout */
994 socket_timeout=atoi(optarg);
995 if (socket_timeout<=0)
996 return ERROR;
997 }
999 }
1001 return OK;
1002 }
1006 void print_help(void)
1007 {
1008 char *myport;
1009 asprintf (&myport, "%d", PORT);
1011 print_revision (progname, revision);
1013 printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
1014 printf (COPYRIGHT, copyright, email);
1016 printf ("%s\n", _("This plugin attempts to contact the MRTGEXT NLM running on a"));
1017 printf ("%s\n", _("Novell server to gather the requested system information."));
1019 printf ("\n\n");
1021 print_usage();
1023 printf (_(UT_HELP_VRSN));
1025 printf (_(UT_HOST_PORT), 'p', myport);
1027 printf (_("\
1028 -v, --variable=STRING\n\
1029 Variable to check. Valid variables include:\n\
1030 LOAD1 = 1 minute average CPU load\n\
1031 LOAD5 = 5 minute average CPU load\n\
1032 LOAD15 = 15 minute average CPU load\n\
1033 CSPROCS = number of current service processes (NW 5.x only)\n\
1034 ABENDS = number of abended threads (NW 5.x only)\n\
1035 UPTIME = server uptime\n"));
1037 printf (_("\
1038 LTCH = percent long term cache hits\n\
1039 CBUFF = current number of cache buffers\n\
1040 CDBUFF = current number of dirty cache buffers\n\
1041 DCB = dirty cache buffers as a percentage of the total\n\
1042 TCB = dirty cache buffers as a percentage of the original\n"));
1044 printf (_("\
1045 OFILES = number of open files\n\
1046 VPF<vol> = percent free space on volume <vol>\n\
1047 VKF<vol> = KB of free space on volume <vol>\n\
1048 VPP<vol> = percent purgeable space on volume <vol>\n\
1049 VKP<vol> = KB of purgeable space on volume <vol>\n\
1050 VPNP<vol> = percent not yet purgeable space on volume <vol>\n\
1051 VKNP<vol> = KB of not yet purgeable space on volume <vol>\n"));
1053 printf (_("\
1054 LRUM = LRU sitting time in minutes\n\
1055 LRUS = LRU sitting time in seconds\n\
1056 DSDB = check to see if DS Database is open\n\
1057 DSVER = NDS version\n\
1058 UPRB = used packet receive buffers\n\
1059 PUPRB = percent (of max) used packet receive buffers\n\
1060 SAPENTRIES = number of entries in the SAP table\n\
1061 SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>\n"));
1063 printf (_("\
1064 TSYNC = timesync status \n\
1065 LOGINS = check to see if logins are enabled\n\
1066 CONNS = number of currently licensed connections\n\
1067 NLM:<nlm> = check if NLM is loaded and report version\n\
1068 (e.g. \"NLM:TSANDS.NLM\")\n"));
1070 printf (_("\
1071 -w, --warning=INTEGER\n\
1072 Threshold which will result in a warning status\n\
1073 -c, --critical=INTEGER\n\
1074 Threshold which will result in a critical status\n\
1075 -o, --osversion\n\
1076 Include server version string in results\n"));
1078 printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
1080 printf ("\n");
1081 printf ("%s\n", _("Notes:"));
1082 printf (_("\
1083 - This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG\n\
1084 extension for NetWare be loaded on the Novell servers you wish to check.\n\
1085 (available from http://www.engr.wisc.edu/~drews/mrtg/)\n\
1086 - Values for critical thresholds should be lower than warning thresholds\n\
1087 when the following variables are checked: VPF, VKF, LTCH, CBUFF, DCB, \n\
1088 TCB, LRUS and LRUM.\n"));
1090 printf (_(UT_SUPPORT));
1091 }
1095 void print_usage(void)
1096 {
1097 printf (_("Usage:"));
1098 printf ("%s -H host [-p port] [-v variable] [-w warning] [-c critical] [-t timeout]\n",progname);
1099 }