?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix INADDR_NONE value (for systems which don't define it).
[monitoring-plugins.git] / plugins / check_nwstat.c
blob37e92290178e849f6cc7ddda8dc000d45b51a690
1 /******************************************************************************
2 *
3 * Nagios check_nwstat plugin
4 *
5 * License: GPL
6 * Copyright (c) 2000-2006 nagios-plugins team
7 *
8 * Last Modified: $Date$
9 *
10 * Description:
11 *
12 * This file contains the check_nwstat plugin
13 *
14 * This plugin attempts to contact the MRTGEXT NLM running on a
15 * Novell server to gather the requested system information.
16 *
17 *
18 * License Information:
19 *
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License as published by
22 * the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
24 *
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
29 *
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33
34 $Id$
35
36 ******************************************************************************/
37
38 const char *progname = "check_nwstat";
39 const char *revision = "$Revision$";
40 const char *copyright = "2000-2006";
41 const char *email = "nagiosplug-devel@lists.sourceforge.net";
42
43 #include "common.h"
44 #include "netutils.h"
45 #include "utils.h"
46
47 enum checkvar {
48 NONE,
49 LOAD1, /* check 1 minute CPU load */
50 LOAD5, /* check 5 minute CPU load */
51 LOAD15, /* check 15 minute CPU load */
52 CONNS, /* check number of connections */
53 VPF, /* check % free space on volume */
54 VMF, /* check MB free space on volume */
55 VMU, /* check MB used space on volume */
56 VMP, /* check MB purgeable space on volume */
57 VKF, /* check KB free space on volume */
58 LTCH, /* check long-term cache hit percentage */
59 CBUFF, /* check total cache buffers */
60 CDBUFF, /* check dirty cache buffers */
61 LRUM, /* check LRU sitting time in minutes */
62 DSDB, /* check to see if DS Database is open */
63 LOGINS, /* check to see if logins are enabled */
64 NRMH, /* check to see NRM Health Status */
65 PUPRB, /* check % of used packet receive buffers */
66 UPRB, /* check used packet receive buffers */
67 SAPENTRIES, /* check SAP entries */
68 OFILES, /* check number of open files */
69 VKP, /* check KB purgeable space on volume */
70 VPP, /* check % purgeable space on volume */
71 VKNP, /* check KB not yet purgeable space on volume */
72 VPNP, /* check % not yet purgeable space on volume */
73 ABENDS, /* check abended thread count */
74 CSPROCS, /* check number of current service processes */
75 TSYNC, /* check timesync status 0=no 1=yes in sync to the network */
76 LRUS, /* check LRU sitting time in seconds */
77 DCB, /* check dirty cache buffers as a percentage of the total */
78 TCB, /* check total cache buffers as a percentage of the original */
79 DSVER, /* check NDS version */
80 UPTIME, /* check server uptime */
81 NLM, /* check NLM loaded */
82 NRMP, /* check NRM Process Values */
83 NRMM, /* check NRM Memory Values */
84 NRMS, /* check NRM Values */
85 NSS1, /* check Statistics from _Admin:Manage_NSS\GeneralStats.xml */
86 NSS2, /* check Statistics from _Admin:Manage_NSS\BufferCache.xml */
87 NSS3, /* check statistics from _Admin:Manage_NSS\NameCache.xml */
88 NSS4, /* check statistics from _Admin:Manage_NSS\FileStats.xml */
89 NSS5, /* check statistics from _Admin:Manage_NSS\ObjectCache.xml */
90 NSS6, /* check statistics from _Admin:Manage_NSS\Thread.xml */
91 NSS7 /* check statistics from _Admin:Manage_NSS\AuthorizationCache.xml */
92 };
93
94 enum {
95 PORT = 9999
96 };
97
98 char *server_address=NULL;
99 char *volume_name=NULL;
100 char *nlm_name=NULL;
101 char *nrmp_name=NULL;
102 char *nrmm_name=NULL;
103 char *nrms_name=NULL;
104 char *nss1_name=NULL;
105 char *nss2_name=NULL;
106 char *nss3_name=NULL;
107 char *nss4_name=NULL;
108 char *nss5_name=NULL;
109 char *nss6_name=NULL;
110 char *nss7_name=NULL;
111 int server_port=PORT;
112 unsigned long warning_value=0L;
113 unsigned long critical_value=0L;
114 int check_warning_value=FALSE;
115 int check_critical_value=FALSE;
116 int check_netware_version=FALSE;
117 enum checkvar vars_to_check = NONE;
118 int sap_number=-1;
119
120 int process_arguments(int, char **);
121 void print_help(void);
122 void print_usage(void);
123
124
125
126 int
127 main(int argc, char **argv) {
128 int result = STATE_UNKNOWN;
129 int sd;
130 char *send_buffer=NULL;
131 char recv_buffer[MAX_INPUT_BUFFER];
132 char *output_message=NULL;
133 char *temp_buffer=NULL;
134 char *netware_version=NULL;
135
136 int time_sync_status=0;
137 int nrm_health_status=0;
138 unsigned long total_cache_buffers=0;
139 unsigned long dirty_cache_buffers=0;
140 unsigned long open_files=0;
141 unsigned long abended_threads=0;
142 unsigned long max_service_processes=0;
143 unsigned long current_service_processes=0;
144 unsigned long free_disk_space=0L;
145 unsigned long nrmp_value=0L;
146 unsigned long nrmm_value=0L;
147 unsigned long nrms_value=0L;
148 unsigned long nss1_value=0L;
149 unsigned long nss2_value=0L;
150 unsigned long nss3_value=0L;
151 unsigned long nss4_value=0L;
152 unsigned long nss5_value=0L;
153 unsigned long nss6_value=0L;
154 unsigned long nss7_value=0L;
155 unsigned long total_disk_space=0L;
156 unsigned long purgeable_disk_space=0L;
157 unsigned long non_purgeable_disk_space=0L;
158 unsigned long percent_free_space=0;
159 unsigned long percent_purgeable_space=0;
160 unsigned long percent_non_purgeable_space=0;
161 unsigned long current_connections=0L;
162 unsigned long utilization=0L;
163 unsigned long cache_hits=0;
164 unsigned long cache_buffers=0L;
165 unsigned long lru_time=0L;
166 unsigned long max_packet_receive_buffers=0;
167 unsigned long used_packet_receive_buffers=0;
168 unsigned long percent_used_packet_receive_buffers=0L;
169 unsigned long sap_entries=0;
170 char uptime[MAX_INPUT_BUFFER];
171
172 setlocale (LC_ALL, "");
173 bindtextdomain (PACKAGE, LOCALEDIR);
174 textdomain (PACKAGE);
175
176 if (process_arguments(argc,argv) == ERROR)
177 usage4 (_("Could not parse arguments"));
178
179 /* initialize alarm signal handling */
180 signal(SIGALRM,socket_timeout_alarm_handler);
181
182 /* set socket timeout */
183 alarm(socket_timeout);
184
185 /* open connection */
186 my_tcp_connect (server_address, server_port, &sd);
187
188 /* get OS version string */
189 if (check_netware_version==TRUE) {
190 send_buffer = strdup ("S19\r\n");
191 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
192 if (result!=STATE_OK)
193 return result;
194 if (!strcmp(recv_buffer,"-1\n"))
195 netware_version = strdup("");
196 else {
197 recv_buffer[strlen(recv_buffer)-1]=0;
198 asprintf (&netware_version,_("NetWare %s: "),recv_buffer);
199 }
200 } else
201 netware_version = strdup("");
202
203
204 /* check CPU load */
205 if (vars_to_check==LOAD1 || vars_to_check==LOAD5 || vars_to_check==LOAD15) {
206
207 switch(vars_to_check) {
208 case LOAD1:
209 temp_buffer = strdup ("1");
210 break;
211 case LOAD5:
212 temp_buffer = strdup ("5");
213 break;
214 default:
215 temp_buffer = strdup ("15");
216 break;
217 }
218
219 close(sd);
220 my_tcp_connect (server_address, server_port, &sd);
221
222 asprintf (&send_buffer,"UTIL%s\r\n",temp_buffer);
223 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
224 if (result!=STATE_OK)
225 return result;
226 utilization=strtoul(recv_buffer,NULL,10);
227
228 close(sd);
229 my_tcp_connect (server_address, server_port, &sd);
230
231 send_buffer = strdup ("UPTIME\r\n");
232 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
233 if (result!=STATE_OK)
234 return result;
235 recv_buffer[strlen(recv_buffer)-1]=0;
236 sprintf(uptime,_("Up %s,"),recv_buffer);
237
238 if (check_critical_value==TRUE && utilization >= critical_value)
239 result=STATE_CRITICAL;
240 else if (check_warning_value==TRUE && utilization >= warning_value)
241 result=STATE_WARNING;
242
243 asprintf (&output_message,
244 _("Load %s - %s %s-min load average = %lu%%|load%s=%lu;%lu;%lu;0;100"),
245 state_text(result),
246 uptime,
247 temp_buffer,
248 utilization,
249 temp_buffer,
250 utilization,
251 warning_value,
252 critical_value);
253
254 /* check number of user connections */
255 } else if (vars_to_check==CONNS) {
256
257 close(sd);
258 my_tcp_connect (server_address, server_port, &sd);
259
260 send_buffer = strdup ("CONNECT\r\n");
261 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
262 if (result!=STATE_OK)
263 return result;
264 current_connections=strtoul(recv_buffer,NULL,10);
265
266 if (check_critical_value==TRUE && current_connections >= critical_value)
267 result=STATE_CRITICAL;
268 else if (check_warning_value==TRUE && current_connections >= warning_value)
269 result=STATE_WARNING;
270
271 asprintf (&output_message,
272 _("Conns %s - %lu current connections|Conns=%lu;%lu;%lu;;"),
273 state_text(result),
274 current_connections,
275 current_connections,
276 warning_value,
277 critical_value);
278
279 /* check % long term cache hits */
280 } else if (vars_to_check==LTCH) {
281
282 close(sd);
283 my_tcp_connect (server_address, server_port, &sd);
284
285 send_buffer = strdup ("S1\r\n");
286 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
287 if (result!=STATE_OK)
288 return result;
289 cache_hits=atoi(recv_buffer);
290
291 if (check_critical_value==TRUE && cache_hits <= critical_value)
292 result=STATE_CRITICAL;
293 else if (check_warning_value==TRUE && cache_hits <= warning_value)
294 result=STATE_WARNING;
295
296 asprintf (&output_message,
297 _("%s: Long term cache hits = %lu%%"),
298 state_text(result),
299 cache_hits);
300
301 /* check cache buffers */
302 } else if (vars_to_check==CBUFF) {
303
304 close(sd);
305 my_tcp_connect (server_address, server_port, &sd);
306
307 send_buffer = strdup ("S2\r\n");
308 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
309 if (result!=STATE_OK)
310 return result;
311 cache_buffers=strtoul(recv_buffer,NULL,10);
312
313 if (check_critical_value==TRUE && cache_buffers <= critical_value)
314 result=STATE_CRITICAL;
315 else if (check_warning_value==TRUE && cache_buffers <= warning_value)
316 result=STATE_WARNING;
317
318 asprintf (&output_message,
319 _("%s: Total cache buffers = %lu|Cachebuffers=%lu;%lu;%lu;;"),
320 state_text(result),
321 cache_buffers,
322 cache_buffers,
323 warning_value,
324 critical_value);
325
326 /* check dirty cache buffers */
327 } else if (vars_to_check==CDBUFF) {
328
329 close(sd);
330 my_tcp_connect (server_address, server_port, &sd);
331
332 send_buffer = strdup ("S3\r\n");
333 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
334 if (result!=STATE_OK)
335 return result;
336 cache_buffers=strtoul(recv_buffer,NULL,10);
337
338 if (check_critical_value==TRUE && cache_buffers >= critical_value)
339 result=STATE_CRITICAL;
340 else if (check_warning_value==TRUE && cache_buffers >= warning_value)
341 result=STATE_WARNING;
342
343 asprintf (&output_message,
344 _("%s: Dirty cache buffers = %lu|Dirty-Cache-Buffers=%lu;%lu;%lu;;"),
345 state_text(result),
346 cache_buffers,
347 cache_buffers,
348 warning_value,
349 critical_value);
350
351 /* check LRU sitting time in minutes */
352 } else if (vars_to_check==LRUM) {
353
354 close(sd);
355 my_tcp_connect (server_address, server_port, &sd);
356
357 send_buffer = strdup ("S5\r\n");
358 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
359 if (result!=STATE_OK)
360 return result;
361 lru_time=strtoul(recv_buffer,NULL,10);
362
363 if (check_critical_value==TRUE && lru_time <= critical_value)
364 result=STATE_CRITICAL;
365 else if (check_warning_value==TRUE && lru_time <= warning_value)
366 result=STATE_WARNING;
367
368 asprintf (&output_message,
369 _("%s: LRU sitting time = %lu minutes"),
370 state_text(result),
371 lru_time);
372
373
374 /* check KB free space on volume */
375 } else if (vars_to_check==VKF) {
376
377 close(sd);
378 my_tcp_connect (server_address, server_port, &sd);
379
380 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
381 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
382 if (result!=STATE_OK)
383 return result;
384
385 if (!strcmp(recv_buffer,"-1\n")) {
386 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
387 result=STATE_CRITICAL;
388 } else {
389 free_disk_space=strtoul(recv_buffer,NULL,10);
390 if (check_critical_value==TRUE && free_disk_space <= critical_value)
391 result=STATE_CRITICAL;
392 else if (check_warning_value==TRUE && free_disk_space <= warning_value)
393 result=STATE_WARNING;
394 asprintf (&output_message,
395 _("%s%lu KB free on volume %s|KBFree%s=%lu;%lu;%lu;;"),
396 (result==STATE_OK)?"":_("Only "),
397 free_disk_space,
398 volume_name,
399 volume_name,
400 free_disk_space,
401 warning_value,
402 critical_value);
403 }
404
405 /* check MB free space on volume */
406 } else if (vars_to_check==VMF) {
407
408 asprintf (&send_buffer,"VMF%s\r\n",volume_name);
409 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
410 if (result!=STATE_OK)
411 return result;
412
413 if (!strcmp(recv_buffer,"-1\n")) {
414 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
415 result=STATE_CRITICAL;
416 } else {
417 free_disk_space=strtoul(recv_buffer,NULL,10);
418 if (check_critical_value==TRUE && free_disk_space <= critical_value)
419 result=STATE_CRITICAL;
420 else if (check_warning_value==TRUE && free_disk_space <= warning_value)
421 result=STATE_WARNING;
422 asprintf (&output_message,
423 _("%s%lu MB free on volume %s|MBFree%s=%lu;%lu;%lu;;"),
424 (result==STATE_OK)?"":_("Only "),
425 free_disk_space,
426 volume_name,
427 volume_name,
428 free_disk_space,
429 warning_value,
430 critical_value);
431 }
432 /* check MB used space on volume */
433 } else if (vars_to_check==VMU) {
434
435 asprintf (&send_buffer,"VMU%s\r\n",volume_name);
436 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
437 if (result!=STATE_OK)
438 return result;
439
440 if (!strcmp(recv_buffer,"-1\n")) {
441 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
442 result=STATE_CRITICAL;
443 } else {
444 free_disk_space=strtoul(recv_buffer,NULL,10);
445 if (check_critical_value==TRUE && free_disk_space <= critical_value)
446 result=STATE_CRITICAL;
447 else if (check_warning_value==TRUE && free_disk_space <= warning_value)
448 result=STATE_WARNING;
449 asprintf (&output_message,
450 _("%s%lu MB used on volume %s|MBUsed%s=%lu;%lu;%lu;;"),
451 (result==STATE_OK)?"":_("Only "),
452 free_disk_space,
453 volume_name,
454 volume_name,
455 free_disk_space,
456 warning_value,
457 critical_value);
458 }
459
460
461 /* check % free space on volume */
462 } else if (vars_to_check==VPF) {
463
464 close(sd);
465 my_tcp_connect (server_address, server_port, &sd);
466
467 asprintf (&send_buffer,"VKF%s\r\n",volume_name);
468 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
469 if (result!=STATE_OK)
470 return result;
471
472 if (!strcmp(recv_buffer,"-1\n")) {
473
474 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
475 result=STATE_CRITICAL;
476
477 } else {
478
479 free_disk_space=strtoul(recv_buffer,NULL,10);
480
481 close(sd);
482 my_tcp_connect (server_address, server_port, &sd);
483
484 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
485 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
486 if (result!=STATE_OK)
487 return result;
488 total_disk_space=strtoul(recv_buffer,NULL,10);
489
490 percent_free_space=(unsigned long)(((double)free_disk_space/(double)total_disk_space)*100.0);
491
492 if (check_critical_value==TRUE && percent_free_space <= critical_value)
493 result=STATE_CRITICAL;
494 else if (check_warning_value==TRUE && percent_free_space <= warning_value)
495 result=STATE_WARNING;
496 free_disk_space/=1024;
497 total_disk_space/=1024;
498 asprintf (&output_message,_("%lu MB (%lu%%) free on volume %s - total %lu MB|FreeMB%s=%lu;%lu;%lu;0;100"),
499 free_disk_space,
500 percent_free_space,
501 volume_name,
502 total_disk_space,
503 volume_name,
504 percent_free_space,
505 warning_value,
506 critical_value
507 );
508 }
509
510 /* check to see if DS Database is open or closed */
511 } else if (vars_to_check==DSDB) {
512
513 close(sd);
514 my_tcp_connect (server_address, server_port, &sd);
515
516 send_buffer = strdup ("S11\r\n");
517 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
518 if (result!=STATE_OK)
519 return result;
520 if (atoi(recv_buffer)==1)
521 result=STATE_OK;
522 else
523 result=STATE_WARNING;
524
525 close(sd);
526 my_tcp_connect (server_address, server_port, &sd);
527
528 send_buffer = strdup ("S13\r\n");
529 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
530 temp_buffer=strtok(recv_buffer,"\r\n");
531
532 asprintf (&output_message,_("Directory Services Database is %s (DS version %s)"),(result==STATE_OK)?"open":"closed",temp_buffer);
533
534 /* check to see if logins are enabled */
535 } else if (vars_to_check==LOGINS) {
536
537 close(sd);
538 my_tcp_connect (server_address, server_port, &sd);
539
540 send_buffer = strdup ("S12\r\n");
541 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
542 if (result!=STATE_OK)
543 return result;
544 if (atoi(recv_buffer)==1)
545 result=STATE_OK;
546 else
547 result=STATE_WARNING;
548
549 asprintf (&output_message,_("Logins are %s"),(result==STATE_OK)?_("enabled"):_("disabled"));
550
551
552 /* check NRM Health Status Summary*/
553 } else if (vars_to_check==NRMH) {
554
555 asprintf (&send_buffer,"NRMH\r\n");
556 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
557 if (result!=STATE_OK)
558 return result;
559
560 nrm_health_status=atoi(recv_buffer);
561
562 if (nrm_health_status==2) {
563 result=STATE_OK;
564 asprintf (&output_message,_("CRITICAL - NRM Status is bad!"));
565 }
566 else {
567 if (nrm_health_status==1) {
568 result=STATE_WARNING;
569 asprintf (&output_message,_("Warning - NRM Status is suspect!"));
570 }
571
572 asprintf (&output_message,_("OK - NRM Status is good!"));
573 }
574
575
576
577 /* check packet receive buffers */
578 } else if (vars_to_check==UPRB || vars_to_check==PUPRB) {
579
580 close(sd);
581 my_tcp_connect (server_address, server_port, &sd);
582
583 asprintf (&send_buffer,"S15\r\n");
584 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
585 if (result!=STATE_OK)
586 return result;
587
588 used_packet_receive_buffers=atoi(recv_buffer);
589
590 close(sd);
591 my_tcp_connect (server_address, server_port, &sd);
592
593 asprintf (&send_buffer,"S16\r\n");
594 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
595 if (result!=STATE_OK)
596 return result;
597
598 max_packet_receive_buffers=atoi(recv_buffer);
599
600 percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
601
602 if (vars_to_check==UPRB) {
603 if (check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
604 result=STATE_CRITICAL;
605 else if (check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
606 result=STATE_WARNING;
607 } else {
608 if (check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
609 result=STATE_CRITICAL;
610 else if (check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
611 result=STATE_WARNING;
612 }
613
614 asprintf (&output_message,_("%lu of %lu (%lu%%) packet receive buffers used"),used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
615
616 /* check SAP table entries */
617 } else if (vars_to_check==SAPENTRIES) {
618
619 close(sd);
620 my_tcp_connect (server_address, server_port, &sd);
621
622 if (sap_number==-1)
623 asprintf (&send_buffer,"S9\r\n");
624 else
625 asprintf (&send_buffer,"S9.%d\r\n",sap_number);
626 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
627 if (result!=STATE_OK)
628 return result;
629
630 sap_entries=atoi(recv_buffer);
631
632 if (check_critical_value==TRUE && sap_entries >= critical_value)
633 result=STATE_CRITICAL;
634 else if (check_warning_value==TRUE && sap_entries >= warning_value)
635 result=STATE_WARNING;
636
637 if (sap_number==-1)
638 asprintf (&output_message,_("%lu entries in SAP table"),sap_entries);
639 else
640 asprintf (&output_message,_("%lu entries in SAP table for SAP type %d"),sap_entries,sap_number);
641
642 /* check KB purgeable space on volume */
643 } else if (vars_to_check==VKP) {
644
645 close(sd);
646 my_tcp_connect (server_address, server_port, &sd);
647
648 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
649 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
650 if (result!=STATE_OK)
651 return result;
652
653 if (!strcmp(recv_buffer,"-1\n")) {
654 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
655 result=STATE_CRITICAL;
656 } else {
657 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
658 if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
659 result=STATE_CRITICAL;
660 else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
661 result=STATE_WARNING;
662 asprintf (&output_message,_("%s%lu KB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"),
663 (result==STATE_OK)?"":_("Only "),
664 purgeable_disk_space,
665 volume_name,
666 volume_name,
667 purgeable_disk_space,
668 warning_value,
669 critical_value);
670 }
671 /* check MB purgeable space on volume */
672 } else if (vars_to_check==VMP) {
673
674 asprintf (&send_buffer,"VMP%s\r\n",volume_name);
675 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
676 if (result!=STATE_OK)
677 return result;
678
679 if (!strcmp(recv_buffer,"-1\n")) {
680 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
681 result=STATE_CRITICAL;
682 } else {
683 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
684 if (check_critical_value==TRUE && purgeable_disk_space >= critical_value)
685 result=STATE_CRITICAL;
686 else if (check_warning_value==TRUE && purgeable_disk_space >= warning_value)
687 result=STATE_WARNING;
688 asprintf (&output_message,_("%s%lu MB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"),
689 (result==STATE_OK)?"":_("Only "),
690 purgeable_disk_space,
691 volume_name,
692 volume_name,
693 purgeable_disk_space,
694 warning_value,
695 critical_value);
696 }
697
698 /* check % purgeable space on volume */
699 } else if (vars_to_check==VPP) {
700
701 close(sd);
702 my_tcp_connect (server_address, server_port, &sd);
703
704 asprintf (&send_buffer,"VKP%s\r\n",volume_name);
705 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
706 if (result!=STATE_OK)
707 return result;
708
709 if (!strcmp(recv_buffer,"-1\n")) {
710
711 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
712 result=STATE_CRITICAL;
713
714 } else {
715
716 purgeable_disk_space=strtoul(recv_buffer,NULL,10);
717
718 close(sd);
719 my_tcp_connect (server_address, server_port, &sd);
720
721 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
722 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
723 if (result!=STATE_OK)
724 return result;
725 total_disk_space=strtoul(recv_buffer,NULL,10);
726
727 percent_purgeable_space=(unsigned long)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
728
729 if (check_critical_value==TRUE && percent_purgeable_space >= critical_value)
730 result=STATE_CRITICAL;
731 else if (check_warning_value==TRUE && percent_purgeable_space >= warning_value)
732 result=STATE_WARNING;
733 purgeable_disk_space/=1024;
734 asprintf (&output_message,_("%lu MB (%lu%%) purgeable on volume %s|Purgeable%s=%lu;%lu;%lu;0;100"),
735 purgeable_disk_space,
736 percent_purgeable_space,
737 volume_name,
738 volume_name,
739 percent_purgeable_space,
740 warning_value,
741 critical_value
742 );
743 }
744
745 /* check KB not yet purgeable space on volume */
746 } else if (vars_to_check==VKNP) {
747
748 close(sd);
749 my_tcp_connect (server_address, server_port, &sd);
750
751 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
752 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
753 if (result!=STATE_OK)
754 return result;
755
756 if (!strcmp(recv_buffer,"-1\n")) {
757 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
758 result=STATE_CRITICAL;
759 } else {
760 non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
761 if (check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
762 result=STATE_CRITICAL;
763 else if (check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
764 result=STATE_WARNING;
765 asprintf (&output_message,_("%s%lu KB not yet purgeable on volume %s"),(result==STATE_OK)?"":_("Only "),non_purgeable_disk_space,volume_name);
766 }
767
768 /* check % not yet purgeable space on volume */
769 } else if (vars_to_check==VPNP) {
770
771 close(sd);
772 my_tcp_connect (server_address, server_port, &sd);
773
774 asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
775 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
776 if (result!=STATE_OK)
777 return result;
778
779 if (!strcmp(recv_buffer,"-1\n")) {
780
781 asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
782 result=STATE_CRITICAL;
783
784 } else {
785
786 non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
787
788 close(sd);
789 my_tcp_connect (server_address, server_port, &sd);
790
791 asprintf (&send_buffer,"VKS%s\r\n",volume_name);
792 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
793 if (result!=STATE_OK)
794 return result;
795 total_disk_space=strtoul(recv_buffer,NULL,10);
796
797 percent_non_purgeable_space=(unsigned long)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
798
799 if (check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
800 result=STATE_CRITICAL;
801 else if (check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
802 result=STATE_WARNING;
803 purgeable_disk_space/=1024;
804 asprintf (&output_message,_("%lu MB (%lu%%) not yet purgeable on volume %s"),non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
805 }
806
807 /* check # of open files */
808 } else if (vars_to_check==OFILES) {
809
810 close(sd);
811 my_tcp_connect (server_address, server_port, &sd);
812
813 asprintf (&send_buffer,"S18\r\n");
814 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
815 if (result!=STATE_OK)
816 return result;
817
818 open_files=atoi(recv_buffer);
819
820 if (check_critical_value==TRUE && open_files >= critical_value)
821 result=STATE_CRITICAL;
822 else if (check_warning_value==TRUE && open_files >= warning_value)
823 result=STATE_WARNING;
824
825 asprintf (&output_message,_("%lu open files|Openfiles=%lu;%lu;%lu;0,0"),
826 open_files,
827 open_files,
828 warning_value,
829 critical_value);
830
831
832 /* check # of abended threads (Netware > 5.x only) */
833 } else if (vars_to_check==ABENDS) {
834
835 close(sd);
836 my_tcp_connect (server_address, server_port, &sd);
837
838 asprintf (&send_buffer,"S17\r\n");
839 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
840 if (result!=STATE_OK)
841 return result;
842
843 abended_threads=atoi(recv_buffer);
844
845 if (check_critical_value==TRUE && abended_threads >= critical_value)
846 result=STATE_CRITICAL;
847 else if (check_warning_value==TRUE && abended_threads >= warning_value)
848 result=STATE_WARNING;
849
850 asprintf (&output_message,_("%lu abended threads|Abends=%lu;%lu;%lu;;"),
851 abended_threads,
852 abended_threads,
853 warning_value,
854 critical_value);
855
856 /* check # of current service processes (Netware 5.x only) */
857 } else if (vars_to_check==CSPROCS) {
858
859 close(sd);
860 my_tcp_connect (server_address, server_port, &sd);
861
862 asprintf (&send_buffer,"S20\r\n");
863 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
864 if (result!=STATE_OK)
865 return result;
866
867 max_service_processes=atoi(recv_buffer);
868
869 close(sd);
870 my_tcp_connect (server_address, server_port, &sd);
871
872 asprintf (&send_buffer,"S21\r\n");
873 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
874 if (result!=STATE_OK)
875 return result;
876
877 current_service_processes=atoi(recv_buffer);
878
879 if (check_critical_value==TRUE && current_service_processes >= critical_value)
880 result=STATE_CRITICAL;
881 else if (check_warning_value==TRUE && current_service_processes >= warning_value)
882 result=STATE_WARNING;
883
884 asprintf (&output_message,
885 _("%lu current service processes (%lu max)|Processes=%lu;%lu;%lu;0;%lu"),
886 current_service_processes,
887 max_service_processes,
888 current_service_processes,
889 warning_value,
890 critical_value,
891 max_service_processes);
892
893 /* check # Timesync Status */
894 } else if (vars_to_check==TSYNC) {
895
896 close(sd);
897 my_tcp_connect (server_address, server_port, &sd);
898
899 asprintf (&send_buffer,"S22\r\n");
900 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
901 if (result!=STATE_OK)
902 return result;
903
904 time_sync_status=atoi(recv_buffer);
905
906 if (time_sync_status==0) {
907 result=STATE_CRITICAL;
908 asprintf (&output_message,_("CRITICAL - Time not in sync with network!"));
909 }
910 else {
911 asprintf (&output_message,_("OK - Time in sync with network!"));
912 }
913
914
915
916
917
918 /* check LRU sitting time in secondss */
919 } else if (vars_to_check==LRUS) {
920
921 close(sd);
922 my_tcp_connect (server_address, server_port, &sd);
923
924 send_buffer = strdup ("S4\r\n");
925 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
926 if (result!=STATE_OK)
927 return result;
928 lru_time=strtoul(recv_buffer,NULL,10);
929
930 if (check_critical_value==TRUE && lru_time <= critical_value)
931 result=STATE_CRITICAL;
932 else if (check_warning_value==TRUE && lru_time <= warning_value)
933 result=STATE_WARNING;
934 asprintf (&output_message,_("LRU sitting time = %lu seconds"),lru_time);
935
936
937 /* check % dirty cacheobuffers as a percentage of the total*/
938 } else if (vars_to_check==DCB) {
939
940 close(sd);
941 my_tcp_connect (server_address, server_port, &sd);
942
943 send_buffer = strdup ("S6\r\n");
944 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
945 if (result!=STATE_OK)
946 return result;
947 dirty_cache_buffers=atoi(recv_buffer);
948
949 if (check_critical_value==TRUE && dirty_cache_buffers <= critical_value)
950 result=STATE_CRITICAL;
951 else if (check_warning_value==TRUE && dirty_cache_buffers <= warning_value)
952 result=STATE_WARNING;
953 asprintf (&output_message,_("Dirty cache buffers = %lu%% of the total|DCB=%lu;%lu;%lu;0;100"),
954 dirty_cache_buffers,
955 dirty_cache_buffers,
956 warning_value,
957 critical_value);
958
959 /* check % total cache buffers as a percentage of the original*/
960 } else if (vars_to_check==TCB) {
961
962 close(sd);
963 my_tcp_connect (server_address, server_port, &sd);
964
965 send_buffer = strdup ("S7\r\n");
966 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
967 if (result!=STATE_OK)
968 return result;
969 total_cache_buffers=atoi(recv_buffer);
970
971 if (check_critical_value==TRUE && total_cache_buffers <= critical_value)
972 result=STATE_CRITICAL;
973 else if (check_warning_value==TRUE && total_cache_buffers <= warning_value)
974 result=STATE_WARNING;
975 asprintf (&output_message,_("Total cache buffers = %lu%% of the original|TCB=%lu;%lu;%lu;0;100"),
976 total_cache_buffers,
977 total_cache_buffers,
978 warning_value,
979 critical_value);
980
981 } else if (vars_to_check==DSVER) {
982
983 close(sd);
984 my_tcp_connect (server_address, server_port, &sd);
985
986 asprintf (&send_buffer,"S13\r\n");
987 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
988 if (result!=STATE_OK)
989 return result;
990
991 recv_buffer[strlen(recv_buffer)-1]=0;
992
993 asprintf (&output_message,_("NDS Version %s"),recv_buffer);
994
995 } else if (vars_to_check==UPTIME) {
996
997 close(sd);
998 my_tcp_connect (server_address, server_port, &sd);
999
1000 asprintf (&send_buffer,"UPTIME\r\n");
1001 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1002 if (result!=STATE_OK)
1003 return result;
1004
1005
1006 recv_buffer[sizeof(recv_buffer)-1]=0;
1007 recv_buffer[strlen(recv_buffer)-1]=0;
1008
1009 asprintf (&output_message,_("Up %s"),recv_buffer);
1010
1011 } else if (vars_to_check==NLM) {
1012
1013 close(sd);
1014 my_tcp_connect (server_address, server_port, &sd);
1015
1016 asprintf (&send_buffer,"S24:%s\r\n",nlm_name);
1017 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1018 if (result!=STATE_OK)
1019 return result;
1020
1021 recv_buffer[strlen(recv_buffer)-1]=0;
1022 if (strcmp(recv_buffer,"-1")) {
1023 asprintf (&output_message,_("Module %s version %s is loaded"),nlm_name,recv_buffer);
1024 } else {
1025 result=STATE_CRITICAL;
1026 asprintf (&output_message,_("Module %s is not loaded"),nlm_name);
1027
1028 }
1029 } else if (vars_to_check==NRMP) {
1030
1031 asprintf (&send_buffer,"NRMP:%s\r\n",nrmp_name);
1032 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1033 if (result!=STATE_OK)
1034 return result;
1035
1036 if (!strcmp(recv_buffer,"-1\n")) {
1037 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrmp_name);
1038 result=STATE_CRITICAL;
1039 } else {
1040 nrmp_value=strtoul(recv_buffer,NULL,10);
1041 if (check_critical_value==TRUE && nrmp_value <= critical_value)
1042 result=STATE_CRITICAL;
1043 else if (check_warning_value==TRUE && nrmp_value <= warning_value)
1044 result=STATE_WARNING;
1045 asprintf (&output_message,
1046 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1047 nrmp_name,
1048 nrmp_value,
1049 nrmp_name,
1050 nrmp_value,
1051 warning_value,
1052 critical_value);
1053 }
1054
1055 } else if (vars_to_check==NRMM) {
1056
1057 asprintf (&send_buffer,"NRMM:%s\r\n",nrmm_name);
1058 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1059 if (result!=STATE_OK)
1060 return result;
1061
1062 if (!strcmp(recv_buffer,"-1\n")) {
1063 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrmm_name);
1064 result=STATE_CRITICAL;
1065 } else {
1066 nrmm_value=strtoul(recv_buffer,NULL,10);
1067 if (check_critical_value==TRUE && nrmm_value <= critical_value)
1068 result=STATE_CRITICAL;
1069 else if (check_warning_value==TRUE && nrmm_value <= warning_value)
1070 result=STATE_WARNING;
1071 asprintf (&output_message,
1072 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1073 nrmm_name,
1074 nrmm_value,
1075 nrmm_name,
1076 nrmm_value,
1077 warning_value,
1078 critical_value);
1079 }
1080
1081 } else if (vars_to_check==NRMS) {
1082
1083 asprintf (&send_buffer,"NRMS:%s\r\n",nrms_name);
1084 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1085 if (result!=STATE_OK)
1086 return result;
1087
1088 if (!strcmp(recv_buffer,"-1\n")) {
1089 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrms_name);
1090 result=STATE_CRITICAL;
1091 } else {
1092 nrms_value=strtoul(recv_buffer,NULL,10);
1093 if (check_critical_value==TRUE && nrms_value >= critical_value)
1094 result=STATE_CRITICAL;
1095 else if (check_warning_value==TRUE && nrms_value >= warning_value)
1096 result=STATE_WARNING;
1097 asprintf (&output_message,
1098 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1099 nrms_name,
1100 nrms_value,
1101 nrms_name,
1102 nrms_value,
1103 warning_value,
1104 critical_value);
1105 }
1106
1107 } else if (vars_to_check==NSS1) {
1108
1109 asprintf (&send_buffer,"NSS1:%s\r\n",nss1_name);
1110 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1111 if (result!=STATE_OK)
1112 return result;
1113
1114 if (!strcmp(recv_buffer,"-1\n")) {
1115 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss1_name);
1116 result=STATE_CRITICAL;
1117 } else {
1118 nss1_value=strtoul(recv_buffer,NULL,10);
1119 if (check_critical_value==TRUE && nss1_value >= critical_value)
1120 result=STATE_CRITICAL;
1121 else if (check_warning_value==TRUE && nss1_value >= warning_value)
1122 result=STATE_WARNING;
1123 asprintf (&output_message,
1124 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1125 nss1_name,
1126 nss1_value,
1127 nss1_name,
1128 nss1_value,
1129 warning_value,
1130 critical_value);
1131 }
1132
1133 } else if (vars_to_check==NSS2) {
1134
1135 asprintf (&send_buffer,"NSS2:%s\r\n",nss2_name);
1136 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1137 if (result!=STATE_OK)
1138 return result;
1139
1140 if (!strcmp(recv_buffer,"-1\n")) {
1141 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss2_name);
1142 result=STATE_CRITICAL;
1143 } else {
1144 nss2_value=strtoul(recv_buffer,NULL,10);
1145 if (check_critical_value==TRUE && nss2_value >= critical_value)
1146 result=STATE_CRITICAL;
1147 else if (check_warning_value==TRUE && nss2_value >= warning_value)
1148 result=STATE_WARNING;
1149 asprintf (&output_message,
1150 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1151 nss2_name,
1152 nss2_value,
1153 nss2_name,
1154 nss2_value,
1155 warning_value,
1156 critical_value);
1157 }
1158
1159 } else if (vars_to_check==NSS3) {
1160
1161 asprintf (&send_buffer,"NSS3:%s\r\n",nss3_name);
1162 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1163 if (result!=STATE_OK)
1164 return result;
1165
1166 if (!strcmp(recv_buffer,"-1\n")) {
1167 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss3_name);
1168 result=STATE_CRITICAL;
1169 } else {
1170 nss3_value=strtoul(recv_buffer,NULL,10);
1171 if (check_critical_value==TRUE && nss3_value >= critical_value)
1172 result=STATE_CRITICAL;
1173 else if (check_warning_value==TRUE && nss3_value >= warning_value)
1174 result=STATE_WARNING;
1175 asprintf (&output_message,
1176 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1177 nss3_name,
1178 nss3_value,
1179 nss3_name,
1180 nss3_value,
1181 warning_value,
1182 critical_value);
1183 }
1184
1185 } else if (vars_to_check==NSS4) {
1186
1187 asprintf (&send_buffer,"NSS4:%s\r\n",nss4_name);
1188 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1189 if (result!=STATE_OK)
1190 return result;
1191
1192 if (!strcmp(recv_buffer,"-1\n")) {
1193 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss4_name);
1194 result=STATE_CRITICAL;
1195 } else {
1196 nss4_value=strtoul(recv_buffer,NULL,10);
1197 if (check_critical_value==TRUE && nss4_value >= critical_value)
1198 result=STATE_CRITICAL;
1199 else if (check_warning_value==TRUE && nss4_value >= warning_value)
1200 result=STATE_WARNING;
1201 asprintf (&output_message,
1202 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1203 nss4_name,
1204 nss4_value,
1205 nss4_name,
1206 nss4_value,
1207 warning_value,
1208 critical_value);
1209 }
1210
1211 } else if (vars_to_check==NSS5) {
1212
1213 asprintf (&send_buffer,"NSS5:%s\r\n",nss5_name);
1214 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1215 if (result!=STATE_OK)
1216 return result;
1217
1218 if (!strcmp(recv_buffer,"-1\n")) {
1219 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss5_name);
1220 result=STATE_CRITICAL;
1221 } else {
1222 nss5_value=strtoul(recv_buffer,NULL,10);
1223 if (check_critical_value==TRUE && nss5_value >= critical_value)
1224 result=STATE_CRITICAL;
1225 else if (check_warning_value==TRUE && nss5_value >= warning_value)
1226 result=STATE_WARNING;
1227 asprintf (&output_message,
1228 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1229 nss5_name,
1230 nss5_value,
1231 nss5_name,
1232 nss5_value,
1233 warning_value,
1234 critical_value);
1235 }
1236
1237 } else if (vars_to_check==NSS6) {
1238
1239 asprintf (&send_buffer,"NSS6:%s\r\n",nss6_name);
1240 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1241 if (result!=STATE_OK)
1242 return result;
1243
1244 if (!strcmp(recv_buffer,"-1\n")) {
1245 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss6_name);
1246 result=STATE_CRITICAL;
1247 } else {
1248 nss6_value=strtoul(recv_buffer,NULL,10);
1249 if (check_critical_value==TRUE && nss6_value >= critical_value)
1250 result=STATE_CRITICAL;
1251 else if (check_warning_value==TRUE && nss6_value >= warning_value)
1252 result=STATE_WARNING;
1253 asprintf (&output_message,
1254 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1255 nss6_name,
1256 nss6_value,
1257 nss6_name,
1258 nss6_value,
1259 warning_value,
1260 critical_value);
1261 }
1262
1263 } else if (vars_to_check==NSS7) {
1264
1265 asprintf (&send_buffer,"NSS7:%s\r\n",nss7_name);
1266 result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
1267 if (result!=STATE_OK)
1268 return result;
1269
1270 if (!strcmp(recv_buffer,"-1\n")) {
1271 asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss7_name);
1272 result=STATE_CRITICAL;
1273 } else {
1274 nss7_value=strtoul(recv_buffer,NULL,10);
1275 if (check_critical_value==TRUE && nss7_value >= critical_value)
1276 result=STATE_CRITICAL;
1277 else if (check_warning_value==TRUE && nss7_value >= warning_value)
1278 result=STATE_WARNING;
1279 asprintf (&output_message,
1280 _("%s is %lu|%s=%lu;%lu;%lu;;"),
1281 nss7_name,
1282 nss7_value,
1283 nss7_name,
1284 nss7_value,
1285 warning_value,
1286 critical_value);
1287 }
1288
1289
1290 }
1291 else {
1292
1293 output_message = strdup (_("Nothing to check!\n"));
1294 result=STATE_UNKNOWN;
1295
1296 }
1297
1298 close (sd);
1299
1300 /* reset timeout */
1301 alarm(0);
1302
1303 printf("%s%s\n",netware_version,output_message);
1304
1305 return result;
1306 }
1307
1308
1309
1310 /* process command-line arguments */
1311 int process_arguments(int argc, char **argv) {
1312 int c;
1313
1314 int option = 0;
1315 static struct option longopts[] =
1316 {
1317 {"port", required_argument,0,'p'},
1318 {"timeout", required_argument,0,'t'},
1319 {"critical", required_argument,0,'c'},
1320 {"warning", required_argument,0,'w'},
1321 {"variable", required_argument,0,'v'},
1322 {"hostname", required_argument,0,'H'},
1323 {"osversion",no_argument, 0,'o'},
1324 {"version", no_argument, 0,'V'},
1325 {"help", no_argument, 0,'h'},
1326 {0,0,0,0}
1327 };
1328
1329 /* no options were supplied */
1330 if (argc<2) return ERROR;
1331
1332 /* backwards compatibility */
1333 if (! is_option(argv[1])) {
1334 server_address=argv[1];
1335 argv[1]=argv[0];
1336 argv=&argv[1];
1337 argc--;
1338 }
1339
1340 for (c=1;c<argc;c++) {
1341 if (strcmp("-to",argv[c])==0)
1342 strcpy(argv[c],"-t");
1343 else if (strcmp("-wv",argv[c])==0)
1344 strcpy(argv[c],"-w");
1345 else if (strcmp("-cv",argv[c])==0)
1346 strcpy(argv[c],"-c");
1347 }
1348
1349 while (1) {
1350 c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",longopts,&option);
1351
1352 if (c==-1||c==EOF||c==1)
1353 break;
1354
1355 switch (c)
1356 {
1357 case '?': /* print short usage statement if args not parsable */
1358 usage5 ();
1359 case 'h': /* help */
1360 print_help();
1361 exit(STATE_OK);
1362 case 'V': /* version */
1363 print_revision(progname, revision);
1364 exit(STATE_OK);
1365 case 'H': /* hostname */
1366 server_address=optarg;
1367 break;
1368 case 'o': /* display nos version */
1369 check_netware_version=TRUE;
1370 break;
1371 case 'p': /* port */
1372 if (is_intnonneg(optarg))
1373 server_port=atoi(optarg);
1374 else
1375 die(STATE_UNKNOWN,_("Server port an integer\n"));
1376 break;
1377 case 'v':
1378 if (strlen(optarg)<3)
1379 return ERROR;
1380 if (!strcmp(optarg,"LOAD1"))
1381 vars_to_check=LOAD1;
1382 else if (!strcmp(optarg,"LOAD5"))
1383 vars_to_check=LOAD5;
1384 else if (!strcmp(optarg,"LOAD15"))
1385 vars_to_check=LOAD15;
1386 else if (!strcmp(optarg,"CONNS"))
1387 vars_to_check=CONNS;
1388 else if (!strcmp(optarg,"LTCH"))
1389 vars_to_check=LTCH;
1390 else if (!strcmp(optarg,"DCB"))
1391 vars_to_check=DCB;
1392 else if (!strcmp(optarg,"TCB"))
1393 vars_to_check=TCB;
1394 else if (!strcmp(optarg,"CBUFF"))
1395 vars_to_check=CBUFF;
1396 else if (!strcmp(optarg,"CDBUFF"))
1397 vars_to_check=CDBUFF;
1398 else if (!strcmp(optarg,"LRUM"))
1399 vars_to_check=LRUM;
1400 else if (!strcmp(optarg,"LRUS"))
1401 vars_to_check=LRUS;
1402 else if (strncmp(optarg,"VPF",3)==0) {
1403 vars_to_check=VPF;
1404 volume_name = strdup (optarg+3);
1405 if (!strcmp(volume_name,""))
1406 volume_name = strdup ("SYS");
1407 }
1408 else if (strncmp(optarg,"VKF",3)==0) {
1409 vars_to_check=VKF;
1410 volume_name = strdup (optarg+3);
1411 if (!strcmp(volume_name,""))
1412 volume_name = strdup ("SYS");
1413 }
1414 else if (strncmp(optarg,"VMF",3)==0) {
1415 vars_to_check=VMF;
1416 volume_name = strdup (optarg+3);
1417 if (!strcmp(volume_name,""))
1418 volume_name = strdup ("SYS");
1419 }
1420 else if (!strcmp(optarg,"DSDB"))
1421 vars_to_check=DSDB;
1422 else if (!strcmp(optarg,"LOGINS"))
1423 vars_to_check=LOGINS;
1424 else if (!strcmp(optarg,"NRMH"))
1425 vars_to_check=NRMH;
1426 else if (!strcmp(optarg,"UPRB"))
1427 vars_to_check=UPRB;
1428 else if (!strcmp(optarg,"PUPRB"))
1429 vars_to_check=PUPRB;
1430 else if (!strncmp(optarg,"SAPENTRIES",10)) {
1431 vars_to_check=SAPENTRIES;
1432 if (strlen(optarg)>10)
1433 sap_number=atoi(optarg+10);
1434 else
1435 sap_number=-1;
1436 }
1437 else if (!strcmp(optarg,"OFILES"))
1438 vars_to_check=OFILES;
1439 else if (strncmp(optarg,"VKP",3)==0) {
1440 vars_to_check=VKP;
1441 volume_name = strdup (optarg+3);
1442 if (!strcmp(volume_name,""))
1443 volume_name = strdup ("SYS");
1444 }
1445 else if (strncmp(optarg,"VMP",3)==0) {
1446 vars_to_check=VMP;
1447 volume_name = strdup (optarg+3);
1448 if (!strcmp(volume_name,""))
1449 volume_name = strdup ("SYS");
1450 }
1451 else if (strncmp(optarg,"VMU",3)==0) {
1452 vars_to_check=VMU;
1453 volume_name = strdup (optarg+3);
1454 if (!strcmp(volume_name,""))
1455 volume_name = strdup ("SYS");
1456 }
1457 else if (strncmp(optarg,"VPP",3)==0) {
1458 vars_to_check=VPP;
1459 volume_name = strdup (optarg+3);
1460 if (!strcmp(volume_name,""))
1461 volume_name = strdup ("SYS");
1462 }
1463 else if (strncmp(optarg,"VKNP",4)==0) {
1464 vars_to_check=VKNP;
1465 volume_name = strdup (optarg+4);
1466 if (!strcmp(volume_name,""))
1467 volume_name = strdup ("SYS");
1468 }
1469 else if (strncmp(optarg,"VPNP",4)==0) {
1470 vars_to_check=VPNP;
1471 volume_name = strdup (optarg+4);
1472 if (!strcmp(volume_name,""))
1473 volume_name = strdup("SYS");
1474 }
1475 else if (!strcmp(optarg,"ABENDS"))
1476 vars_to_check=ABENDS;
1477 else if (!strcmp(optarg,"CSPROCS"))
1478 vars_to_check=CSPROCS;
1479 else if (!strcmp(optarg,"TSYNC"))
1480 vars_to_check=TSYNC;
1481 else if (!strcmp(optarg,"DSVER"))
1482 vars_to_check=DSVER;
1483 else if (!strcmp(optarg,"UPTIME")) {
1484 vars_to_check=UPTIME;
1485 }
1486 else if (strncmp(optarg,"NLM:",4)==0) {
1487 vars_to_check=NLM;
1488 nlm_name=strdup (optarg+4);
1489 }
1490 else if (strncmp(optarg,"NRMP",4)==0) {
1491 vars_to_check=NRMP;
1492 nrmp_name = strdup (optarg+4);
1493 if (!strcmp(nrmp_name,""))
1494 nrmp_name = strdup ("AVAILABLE_MEMORY");
1495 }
1496 else if (strncmp(optarg,"NRMM",4)==0) {
1497 vars_to_check=NRMM;
1498 nrmm_name = strdup (optarg+4);
1499 if (!strcmp(nrmm_name,""))
1500 nrmm_name = strdup ("AVAILABLE_CACHE_MEMORY");
1501
1502 }
1503
1504 else if (strncmp(optarg,"NRMS",4)==0) {
1505 vars_to_check=NRMS;
1506 nrms_name = strdup (optarg+4);
1507 if (!strcmp(nrms_name,""))
1508 nrms_name = strdup ("USED_SWAP_SPACE");
1509
1510 }
1511
1512 else if (strncmp(optarg,"NSS1",4)==0) {
1513 vars_to_check=NSS1;
1514 nss1_name = strdup (optarg+4);
1515 if (!strcmp(nss1_name,""))
1516 nss1_name = strdup ("CURRENTBUFFERCACHESIZE");
1517
1518 }
1519
1520 else if (strncmp(optarg,"NSS2",4)==0) {
1521 vars_to_check=NSS2;
1522 nss2_name = strdup (optarg+4);
1523 if (!strcmp(nss2_name,""))
1524 nss2_name = strdup ("CACHEHITS");
1525
1526 }
1527
1528 else if (strncmp(optarg,"NSS3",4)==0) {
1529 vars_to_check=NSS3;
1530 nss3_name = strdup (optarg+4);
1531 if (!strcmp(nss3_name,""))
1532 nss3_name = strdup ("CACHEGITPERCENT");
1533
1534 }
1535
1536 else if (strncmp(optarg,"NSS4",4)==0) {
1537 vars_to_check=NSS4;
1538 nss4_name = strdup (optarg+4);
1539 if (!strcmp(nss4_name,""))
1540 nss4_name = strdup ("CURRENTOPENCOUNT");
1541
1542 }
1543
1544 else if (strncmp(optarg,"NSS5",4)==0) {
1545 vars_to_check=NSS5;
1546 nss5_name = strdup (optarg+4);
1547 if (!strcmp(nss5_name,""))
1548 nss5_name = strdup ("CACHEMISSES");
1549
1550 }
1551
1552
1553 else if (strncmp(optarg,"NSS6",4)==0) {
1554 vars_to_check=NSS6;
1555 nss6_name = strdup (optarg+4);
1556 if (!strcmp(nss6_name,""))
1557 nss6_name = strdup ("PENDINGWORKSCOUNT");
1558
1559 }
1560
1561
1562 else if (strncmp(optarg,"NSS7",4)==0) {
1563 vars_to_check=NSS7;
1564 nss7_name = strdup (optarg+4);
1565 if (!strcmp(nss7_name,""))
1566 nss7_name = strdup ("CACHESIZE");
1567
1568 }
1569
1570
1571 else
1572 return ERROR;
1573 break;
1574 case 'w': /* warning threshold */
1575 warning_value=strtoul(optarg,NULL,10);
1576 check_warning_value=TRUE;
1577 break;
1578 case 'c': /* critical threshold */
1579 critical_value=strtoul(optarg,NULL,10);
1580 check_critical_value=TRUE;
1581 break;
1582 case 't': /* timeout */
1583 socket_timeout=atoi(optarg);
1584 if (socket_timeout<=0)
1585 return ERROR;
1586 }
1587
1588 }
1589
1590 return OK;
1591 }
1592
1593
1594
1595 void print_help(void)
1596 {
1597 char *myport;
1598 asprintf (&myport, "%d", PORT);
1599
1600 print_revision (progname, revision);
1601
1602 printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
1603 printf (COPYRIGHT, copyright, email);
1604
1605 printf ("%s\n", _("This plugin attempts to contact the MRTGEXT NLM running on a"));
1606 printf ("%s\n", _("Novell server to gather the requested system information."));
1607
1608 printf ("\n\n");
1609
1610 print_usage();
1611
1612 printf (_(UT_HELP_VRSN));
1613
1614 printf (_(UT_HOST_PORT), 'p', myport);
1615
1616 printf (" %s\n", "-v, --variable=STRING");
1617 printf (" %s\n", _("Variable to check. Valid variables include:"));
1618 printf (" %s\n", _("LOAD1 = 1 minute average CPU load"));
1619 printf (" %s\n", _("LOAD5 = 5 minute average CPU load"));
1620 printf (" %s\n", _("LOAD15 = 15 minute average CPU load"));
1621 printf (" %s\n", _("CSPROCS = number of current service processes (NW 5.x only)"));
1622 printf (" %s\n", _("ABENDS = number of abended threads (NW 5.x only)"));
1623 printf (" %s\n", _("UPTIME = server uptime"));
1624 printf (" %s\n", _("LTCH = percent long term cache hits"));
1625 printf (" %s\n", _("CBUFF = current number of cache buffers"));
1626 printf (" %s\n", _("CDBUFF = current number of dirty cache buffers"));
1627 printf (" %s\n", _("DCB = dirty cache buffers as a percentage of the total"));
1628 printf (" %s\n", _("TCB = dirty cache buffers as a percentage of the original"));
1629 printf (" %s\n", _("OFILES = number of open files"));
1630 printf (" %s\n", _(" VMF<vol> = MB of free space on Volume <vol>"));
1631 printf (" %s\n", _(" VMU<vol> = MB used space on Volume <vol>"));
1632 printf (" %s\n", _(" VMP<vol> = MB of purgeable space on Volume <vol>"));
1633 printf (" %s\n", _(" VPF<vol> = percent free space on volume <vol>"));
1634 printf (" %s\n", _(" VKF<vol> = KB of free space on volume <vol>"));
1635 printf (" %s\n", _(" VPP<vol> = percent purgeable space on volume <vol>"));
1636 printf (" %s\n", _(" VKP<vol> = KB of purgeable space on volume <vol>"));
1637 printf (" %s\n", _(" VPNP<vol> = percent not yet purgeable space on volume <vol>"));
1638 printf (" %s\n", _(" VKNP<vol> = KB of not yet purgeable space on volume <vol>"));
1639 printf (" %s\n", _(" LRUM = LRU sitting time in minutes"));
1640 printf (" %s\n", _(" LRUS = LRU sitting time in seconds"));
1641 printf (" %s\n", _(" DSDB = check to see if DS Database is open"));
1642 printf (" %s\n", _(" DSVER = NDS version"));
1643 printf (" %s\n", _(" UPRB = used packet receive buffers"));
1644 printf (" %s\n", _(" PUPRB = percent (of max) used packet receive buffers"));
1645 printf (" %s\n", _(" SAPENTRIES = number of entries in the SAP table"));
1646 printf (" %s\n", _(" SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>"));
1647 printf (" %s\n", _(" TSYNC = timesync status"));
1648 printf (" %s\n", _(" LOGINS = check to see if logins are enabled"));
1649 printf (" %s\n", _(" CONNS = number of currently licensed connections"));
1650 printf (" %s\n", _(" NRMH = NRM Summary Status"));
1651 printf (" %s\n", _(" NRMP<stat> = Returns the current value for a NRM health item"));
1652 printf (" %s\n", _(" NRMM<stat> = Returns the current memory stats from NRM"));
1653 printf (" %s\n", _(" NRMS<stat> = Returns the current Swapfile stats from NRM"));
1654 printf (" %s\n", _(" NSS1<stat> = Statistics from _Admin:Manage_NSS\\GeneralStats.xml"));
1655 printf (" %s\n", _(" NSS3<stat> = Statistics from _Admin:Manage_NSS\\NameCache.xml"));
1656 printf (" %s\n", _(" NSS4<stat> = Statistics from _Admin:Manage_NSS\\FileStats.xml"));
1657 printf (" %s\n", _(" NSS5<stat> = Statistics from _Admin:Manage_NSS\\ObjectCache.xml"));
1658 printf (" %s\n", _(" NSS6<stat> = Statistics from _Admin:Manage_NSS\\Thread.xml"));
1659 printf (" %s\n", _(" NSS7<stat> = Statistics from _Admin:Manage_NSS\\AuthorizationCache.xml"));
1660 printf (" %s\n", _(" NLM:<nlm> = check if NLM is loaded and report version"));
1661 printf (" %s\n", _(" (e.g. NLM:TSANDS.NLM)"));
1662 printf ("\n");
1663 printf (" %s\n", "-w, --warning=INTEGER");
1664 printf (" %s\n", _("Threshold which will result in a warning status"));
1665 printf (" %s\n", "-c, --critical=INTEGER");
1666 printf (" %s\n", _("Threshold which will result in a critical status"));
1667 printf (" %s\n", "-o, --osversion");
1668 printf (" %s\n", _("Include server version string in results"));
1669
1670 printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
1671
1672 printf ("\n");
1673 printf ("%s\n", _("Notes:"));
1674 printf (" %s\n", _("- This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG"));
1675 printf (" %s\n", _(" extension for NetWare be loaded on the Novell servers you wish to check."));
1676 printf (" %s\n", _(" (available from http://www.engr.wisc.edu/~drews/mrtg/)"));
1677 printf (" %s\n", _("- Values for critical thresholds should be lower than warning thresholds"));
1678 printf (" %s\n", _(" when the following variables are checked: VPF, VKF, LTCH, CBUFF, DCB, "));
1679 printf (" %s\n", _(" TCB, LRUS and LRUM.\n"));
1680
1681 printf (_(UT_SUPPORT));
1682 }
1683
1684
1685
1686 void print_usage(void)
1687 {
1688 printf (_("Usage:"));
1689 printf ("%s -H host [-p port] [-v variable] [-w warning] [-c critical] [-t timeout]\n",progname);
1690 }
Monitoring Plugins