/******************************************************************************
 * CHECK_NC_NET.C - modified from the Check_nt.c in NC_NEt 2.x july 05
 *
 * CHECK_NT.C -was modified from nagios official plugins version 1.4 beta1 
 *				http://sourceforge.net/projects/nagiosplug/
 *				downloaded on Jan 30,2005
 *
 * Program: Windows NT plugin for Nagios
 * License: GPL
 * Copyright (c) 2007 TOny Montibello (tony@MontiTech.com)
 * Support:  NC_Net@MontiTech.com ; 
 *
 * Description:
 * This requires one of the following Windows Servers running:
 * NC_Net availible from (http://sourceforge.net/projects/nc-net)
 * NSClient software to run on NT (http://nsclient.ready2run.nl/)
 * NSClient++ http://sourceforge.net/projects/nscplus/
 *
 * License Information:
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id: check_nc_net.c,v 4.00 2007/03/20 11:51:05 amontibello Exp $
 *
 *****************************************************************************/

const char *progname = "check_nc_net";
const char *revision = "$Revision: 4.4.0 $";
const char *copyright = "2008";
const char *email = "NC_Net@MontiTech.com";

#include "common.h"
#include "netutils.h"
#include "utils.h"

enum checkvars {
	CHECK_NONE,
	CHECK_CLIENTVERSION,	/*1*/
	CHECK_CPULOAD,		/*2*/
	CHECK_UPTIME,		/*3*/
	CHECK_USEDDISKSPACE,	/*4*/
	CHECK_FREEDISKSPACE,	/*13*/
	CHECK_SERVICESTATE,	/*5*/
	CHECK_PROCSTATE,	/*6*/
	CHECK_MEMUSE,		/*7*/
	CHECK_COUNTER,		/*8*/
	CHECK_FILEAGE,		/*9*/
	CHECK_INSTANCES,	/*10*/
	CHECK_EVENTLOG,		/*11*/
	CHECK_WMICHECK,		/*12*/
	CHECK_CONFIG,		/*99*/
	ENUM_CONFIG,		/*18*/
	ENUM_PASSIVE,		/*19*/
	/* ADDPASSIVE - 98 is implemented as a switch -S */
	CONFIG_DELPASSIVE,	/*97*/
	ENUM_PROCESS,		/*17*/
	ENUM_SERVICE,		/*16*/
	CHECK_WMICOUNTER,	/*14*/
	ENUM_COUNTER,		/*15*/
	ENUM_COUNTERDESC,	/*20*/
	CHECK_WMICAT,		/*21*/
	CHECK_RUNSCRIPT,	/*101*/
	ENUM_SCRIPT,		/*102*/
	CONFIG_COPYSCRIPT,	/*103*/
	CONFIG_DELSCRIPT,	/*104*/
	CONFIG_ADDSCRIPT,	/*105*/
	CHECK_CLIENTTIME,	/*22*/
	CHECK_GETALLCHECKS,	/*50*/
	CHECK_GETCHECK,		/*51*/
	ENUM_CHECK,		/*52*/
	CONFIG_DELCHECK,	/*53*/
	CHECK_GETCHECKTIME,	/*54*/
	CHECK_CONFIG_BLIND,	/*100*/
	CHECK_COMMAND_ENUM,	/*106*/
	CHECK_COMMAND_COPY,	/*107*/			
	CHECK_COMMAND_DEL,	/*108*/
	CHECK_COMMAND_PRINT,	/*109*/
	CHECK_RUNSCRIPT_S,	/*110*/
	CHECK_CHANGEPASS,	/*2000*/
	CHECK_ECHO,		/*2003*/
	CHECK_RUN_CMD_FILE,	/*2004*/
	CHECK_RUNSCRIP_RAW_S,	/*2006*/
	CHECK_EVENTLOG_NEW,	/*2009*/
	CHECK_GETALLCHECK_2,	/*2010*/
	CHECK_WMICAT_NEW,	/*2016*/
	CHECK_RUNSCRIP_RAW_A,	/*2029*/
	CHECK_OTHER				

};

enum {
	MAX_VALUE_LIST = 30,
	PORT = 1248
};

char *server_address=NULL;
char *volume_name=NULL;
int server_port=PORT;
char *value_list=NULL;
char *req_password=NULL;
char *service_desc=NULL;
char *check_type=NULL;
unsigned long lvalue_list[MAX_VALUE_LIST];
unsigned long warning_value=0L;
unsigned long critical_value=0L;
int check_warning_value=FALSE;
int check_critical_value=FALSE;
char *critical_value_string=NULL;
char *warning_value_string=NULL;
enum checkvars vars_to_check = CHECK_NONE;
int show_all=FALSE;
int add_passive_check=FALSE;
/*change buffer size from MAX_INPUT_BUFFER to 4096*/
char recv_buffer[4096];
int alternate_tcp_socket=FALSE;

void fetch_data (const char* address, int port, const char* sendb);
int process_arguments(int, char **);
void preparelist(char *string);
void preparelist2(char *string, char c);
int strtoularray(unsigned long *array, char *string, const char *delim);
void print_help(void);
void print_usage(void);
void print_command( char * opts);
static int my_connect2 (const char *host_name, int port, int *sd, int proto);
int process_tcp_request3 (const char *server_address, int server_port,
        const char *send_buffer, char *recv_buffer, int recv_size);


int main(int argc, char **argv){

/* should be 	int result = STATE_UNKNOWN; */

	int return_code = STATE_UNKNOWN;
	char *send_buffer=NULL;
	char *output_message=NULL;
	char *perfdata=NULL;
	char *temp_string=NULL;
	char *temp_string_perf=NULL;
	char *description=NULL,*counter_unit = NULL;
	char *minval = NULL, *maxval = NULL, *errcvt = NULL;

	double total_disk_space=0;
	double free_disk_space=0;
	double percent_used_space=0;
	double warning_used_space=0;
	double critical_used_space=0;
	double mem_commitLimit=0;
	double mem_commitByte=0;
	double fminval = 0, fmaxval = 0;
	unsigned long utilization;
	unsigned long uptime;
	unsigned long age_in_minutes;
	double counter_value = 0.0;
	int offset=0;
	int updays=0;
	int uphours=0;
	int upminutes=0;

	int isPercent = FALSE;
	int allRight = FALSE;

	setlocale (LC_ALL, "");
	bindtextdomain (PACKAGE, LOCALEDIR);
	textdomain (PACKAGE);

	if(process_arguments(argc,argv) == ERROR)
		usage4 (_("Could not parse arguments"));

	/* initialize alarm signal handling */
	signal(SIGALRM,socket_timeout_alarm_handler);

	/* set socket timeout */
	alarm(socket_timeout);

	if ( add_passive_check == TRUE ) {
		asprintf(&send_buffer, "%s&98", req_password); /* Tells NC_Net to add to passive.cfg */
		/*each concatination to original string is a paired set based on args entered*/
		asprintf(&send_buffer, "%s&%s&%s", send_buffer, check_type,service_desc );
		if (check_warning_value==TRUE ) { /* check for warning*/
			asprintf(&send_buffer, "%s&-w&%s", send_buffer, warning_value_string );
		}
		if (check_critical_value==TRUE ) { /* check for critical*/
			asprintf(&send_buffer, "%s&-c&%s", send_buffer, critical_value_string );
		}
		if ( value_list != NULL ) {
			asprintf(&send_buffer, "%s&-l&%s", send_buffer, value_list );
		}
		if ( vars_to_check== CHECK_SERVICESTATE|| vars_to_check ==CHECK_PROCSTATE  ) {
			if (show_all==TRUE) asprintf(&send_buffer, "%s&-d&SHOWALL", send_buffer );
			else	asprintf(&send_buffer, "%s&-d&SHOWFAIL", send_buffer );
		}
		fetch_data (server_address, server_port, send_buffer);
/*		asprintf (&output_message, "Running addpassive check -S: %s -v: %s",service_desc,check_type );*/
		return_code=atoi(strtok(recv_buffer,"&"));
		temp_string=strtok(NULL,"&");
		output_message = strdup (temp_string);
	}
	else  /* run Switch statment*/
	switch (vars_to_check) {

	case CHECK_CLIENTVERSION:

		asprintf(&send_buffer, "%s&1", req_password);
		fetch_data (server_address, server_port, send_buffer);
		if (value_list != NULL && strcmp(recv_buffer, value_list) != 0) {
			asprintf (&output_message, _("Wrong client version - running: %s, required: %s"), recv_buffer, value_list);
			return_code = STATE_WARNING;
		} else {
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_CPULOAD:

		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else if (strtoularray(lvalue_list,value_list,",")==FALSE)
			output_message = strdup (_("wrong -l parameter."));
		else {
			/* -l parameters is present with only integers */
			return_code=STATE_OK;
			temp_string = strdup (_("CPU Load"));
			temp_string_perf = strdup (" ");
      
			/* loop until one of the parameters is wrong or not present */
			while (lvalue_list[0+offset]> (unsigned long)0 &&
						 lvalue_list[0+offset]<=(unsigned long)17280 && 
						 lvalue_list[1+offset]> (unsigned long)0 &&
						 lvalue_list[1+offset]<=(unsigned long)100 && 
						 lvalue_list[2+offset]> (unsigned long)0 &&
						 lvalue_list[2+offset]<=(unsigned long)100) {

				/* Send request and retrieve data */
				asprintf(&send_buffer,"%s&2&%lu",req_password,lvalue_list[0+offset]);
				fetch_data (server_address, server_port, send_buffer);

				utilization=strtoul(recv_buffer,NULL,10);
				
				/* Check if any of the request is in a warning or critical state */
				if(utilization >= lvalue_list[2+offset])
					return_code=STATE_CRITICAL;
				else if(utilization >= lvalue_list[1+offset] && return_code<STATE_WARNING)
					return_code=STATE_WARNING;

				asprintf(&output_message,_(" %lu%% (%lu min average)"), utilization, lvalue_list[0+offset]);
				asprintf(&temp_string,"%s%s",temp_string,output_message);
				asprintf(&perfdata,_(" '%lu min avg Load'=%lu%%;%lu;%lu;0;100"), lvalue_list[0+offset], utilization,
				  lvalue_list[1+offset], lvalue_list[2+offset]);
				asprintf(&temp_string_perf,"%s%s",temp_string_perf,perfdata);
				offset+=3;	/* move across the array */
			}
      
			if (strlen(temp_string)>10) {  /* we had at least one loop */
				output_message = strdup (temp_string);
				perfdata = temp_string_perf;
			} else
				output_message = strdup (_("not enough values for -l parameters"));
		}	
		break;

	case CHECK_UPTIME:

		asprintf(&send_buffer, "%s&3", req_password);
		fetch_data (server_address, server_port, send_buffer);
		uptime=strtoul(recv_buffer,NULL,10);
		updays = uptime / 86400; 			
		uphours = (uptime % 86400) / 3600;
		upminutes = ((uptime % 86400) % 3600) / 60;
		asprintf(&output_message,_("System Uptime - %u day(s) %u hour(s) %u minute(s)"),updays,uphours, upminutes);
		return_code=STATE_OK;
		if( check_critical_value==TRUE && critical_value > updays )
			return_code=STATE_CRITICAL;
		else if ( check_warning_value==TRUE && warning_value > updays )
			return_code=STATE_WARNING;	
		break;

	case CHECK_USEDDISKSPACE:
    case CHECK_FREEDISKSPACE:

		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else if (strlen(value_list)!=1)
			output_message = strdup (_("wrong -l argument"));
		else {
			asprintf(&send_buffer,"%s&4&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			free_disk_space=atof(strtok(recv_buffer,"&"));
			total_disk_space=atof(strtok(NULL,"&"));
			percent_used_space = ((total_disk_space - free_disk_space) / total_disk_space) * 100;
			warning_used_space = ( warning_value > 100 )?warning_value*1024.0*1024:(warning_value*1.0 / 100) * total_disk_space;
			critical_used_space = ( critical_value > 100 )?critical_value*1024.0*1024:(critical_value*1.0 / 100) * total_disk_space;
			if (free_disk_space>=0) {
				asprintf(&temp_string,_("%s: - total: %.2f Gb - used: %.2f Gb (%.0f%%) - free %.2f Gb (%.0f%%)"),
				  value_list, total_disk_space / 1073741824, (total_disk_space - free_disk_space) / 1073741824,
				  percent_used_space, free_disk_space / 1073741824, (free_disk_space / total_disk_space)*100);
				asprintf(&temp_string_perf,_("'%s: Used Space'=%.2fGb;%.2f;%.2f;0.00;%.2f"), value_list,
				  (total_disk_space - free_disk_space) / 1073741824, warning_used_space / 1073741824,
				  critical_used_space / 1073741824, total_disk_space / 1073741824);
				return_code=STATE_OK;	
				if (check_warning_value==TRUE ) { 
					if (vars_to_check==CHECK_FREEDISKSPACE) {
						if ( free_disk_space < warning_used_space ) { return_code=STATE_WARNING; }
					}else { /* test useddiskspace*/
						if ( total_disk_space - free_disk_space > warning_used_space ) { return_code=STATE_WARNING; }
					}
				}
				if (check_critical_value==TRUE ) { 
					if (vars_to_check==CHECK_FREEDISKSPACE) {
						if ( free_disk_space < critical_used_space ) { return_code=STATE_CRITICAL; }
					}else { /* test useddiskspace*/
						if ( total_disk_space - free_disk_space > critical_used_space ) { return_code=STATE_CRITICAL; }
					}
				}
				output_message = strdup (temp_string);
				perfdata = temp_string_perf;
			} else {
				output_message = strdup (_("Free disk space : Invalid drive "));
				return_code=STATE_UNKNOWN;
			}
		}
		break;

	case CHECK_SERVICESTATE:
	case CHECK_PROCSTATE:

		if (value_list==NULL)
			output_message = strdup (_("No service/process specified"));
		else {
			preparelist(value_list);		/* replace , between services with & to send the request */
			asprintf(&send_buffer,"%s&%u&%s&%s", req_password,(vars_to_check==CHECK_SERVICESTATE)?5:6,
							 (show_all==TRUE) ? "ShowAll" : "ShowFail",value_list);
			fetch_data (server_address, server_port, send_buffer);
			return_code=atoi(strtok(recv_buffer,"&"));
			temp_string=strtok(NULL,"&");
			output_message = strdup (temp_string);
		}
		break;

	case CHECK_MEMUSE:
		
		asprintf(&send_buffer,"%s&7", req_password);
		fetch_data (server_address, server_port, send_buffer);
		mem_commitLimit=atof(strtok(recv_buffer,"&"));
		mem_commitByte=atof(strtok(NULL,"&"));
		percent_used_space = (mem_commitByte / mem_commitLimit) * 100;
		warning_used_space = ((float)warning_value / 100) * mem_commitLimit;
		critical_used_space = ((float)critical_value / 100) * mem_commitLimit;

		/* Divisor should be 1048567, not 3044515, as we are measuring "Commit Charge" here, 
		which equals RAM + Pagefiles. */
		asprintf(&output_message,_("Memory usage: total:%.2f Mb - used: %.2f Mb (%.0f%%) - free: %.2f Mb (%.0f%%)"), 
		  mem_commitLimit / 1048567, mem_commitByte / 1048567, percent_used_space,  
		  (mem_commitLimit - mem_commitByte) / 1048567, (mem_commitLimit - mem_commitByte) / mem_commitLimit * 100);
		asprintf(&perfdata,_("'Memory usage'=%.2fMb;%.2f;%.2f;0.00;%.2f"), mem_commitByte / 1048567,
		  warning_used_space / 1048567, critical_used_space / 1048567, mem_commitLimit / 1048567);
	
		return_code=STATE_OK;
		if(check_critical_value==TRUE && percent_used_space >= critical_value)
			return_code=STATE_CRITICAL;
		else if (check_warning_value==TRUE && percent_used_space >= warning_value)
			return_code=STATE_WARNING;	

		break;

	case CHECK_COUNTER:
		/* 
		Check_Counter has been rewriten for NC_Net now it processes the pref data in 
		a more consistent way to the Nagios plug-in development guidelines. 

		1) if no Units of mesurement use a 0 (zero) for the UOM  in the check 
		and the units will be omited from the output.

		2) it will do MIN without a MAX

		3) still processes custom min and max even if it is %

		4) % has a default of min 0, max 100

		5) -w and -c are no longer causing a seg fault. old code said to always
		process both for perf data, but it should have checked that they were in use.
		
		6) the description is only a label for perf data not a formatter...   
       		
		*/
      		if (value_list == NULL)
			output_message = strdup (_("No counter specified"));
      		else {
	  		preparelist (value_list);	/* replace , between services with & to send the request */

	  		temp_string = strtok (value_list, "&");
	 		isPercent = (strchr (temp_string, '%') != NULL);
	  		description = strtok (NULL, "&");
	  		counter_unit = strtok (NULL, "&");
	  		asprintf (&send_buffer, "%s&8&%s", req_password, value_list);
	  		fetch_data (server_address, server_port, send_buffer);
	  		counter_value = atof (recv_buffer);
			if (isPercent)	counter_unit = strdup ("%");
			if ( description != NULL && counter_unit == NULL )
				counter_unit = strdup ( "0" );
			if ( counter_unit != NULL && description != NULL) 
	    		{	
				if ( counter_unit[0] == '0' ) counter_unit[0] = '\0';
				minval = strtok (NULL, "&");
	      			maxval = strtok (NULL, "&");
				if ( minval == NULL && isPercent ) asprintf(&minval,"0");
				if ( minval != NULL ) fminval = strtod ( minval, NULL ) ;
				if ( maxval == NULL && isPercent ) asprintf(&maxval,"100");
				if ( maxval != NULL ) 	fmaxval = strtod (maxval, NULL);
				allRight = TRUE;
	      			/* Let's format the output string, finally... */
				asprintf (&output_message, "%s = %.2f %s", description, counter_value, counter_unit);
	      			asprintf (&output_message,"%s | %s", output_message, 
						fperfdata (description, counter_value, 
							counter_unit, check_warning_value, warning_value,
						       	check_critical_value, critical_value,
							(minval != NULL), fminval,
				   			(maxval != NULL), fmaxval  ));
			}
			else if (isPercent)
				asprintf(&output_message, "%s = %.2f %%",temp_string,counter_value);
			else
				asprintf(&output_message, "%s = %.2f",temp_string,counter_value);
		}
      		if (critical_value > warning_value)
		{			/* Normal thresholds */
	  		if (check_critical_value == TRUE && counter_value >= critical_value)
	    		     return_code = STATE_CRITICAL;
	  		else if (check_warning_value == TRUE && counter_value >= warning_value)
	    			return_code = STATE_WARNING;
	  		     else
	    			return_code = STATE_OK;
		}
      		else
		{			/* inverse thresholds */
	  		return_code = STATE_OK;
	  		if (check_critical_value == TRUE && counter_value <= critical_value)
	    		     return_code = STATE_CRITICAL;
	  		else if (check_warning_value == TRUE && counter_value <= warning_value)
				    return_code = STATE_WARNING;
		}
        break;
		
	case CHECK_FILEAGE:

		if (value_list==NULL)
			output_message = strdup (_("No file specified"));
		else {
			preparelist(value_list);		/* replace , between services with & to send the request */
			asprintf(&send_buffer,"%s&9&%s", req_password,value_list);
			fetch_data (server_address, server_port, send_buffer);
			age_in_minutes = atoi(strtok(recv_buffer,"&"));
			description = strtok(NULL,"&");
			/* output message modified as per several requests */
			/* output_message = strdup (description);  */
	
			if (critical_value > warning_value) {        /* Normal thresholds */
				if(check_critical_value==TRUE && age_in_minutes >= critical_value) 
					return_code=STATE_CRITICAL;
				else if (check_warning_value==TRUE && age_in_minutes >= warning_value)
					return_code=STATE_WARNING;	
				else
					return_code=STATE_OK;	
			} 
			else {                                       /* inverse thresholds */
				if(check_critical_value==TRUE && age_in_minutes <= critical_value)
					return_code=STATE_CRITICAL;
				else if (check_warning_value==TRUE && age_in_minutes <= warning_value)
					return_code=STATE_WARNING;	
				else
					return_code=STATE_OK;	
			}
			if ( return_code == STATE_OK ) 
				asprintf ( &output_message,"OK: %u Minutes, %s", age_in_minutes, value_list);
			else if ( return_code == STATE_WARNING ) 
				asprintf ( &output_message,"WARNING: %u Minutes, %s", age_in_minutes, value_list);
			else if ( return_code == STATE_CRITICAL ) 
				asprintf ( &output_message,"CRITICAL: %u Minutes, %s", age_in_minutes, value_list);
			else
				output_message = strdup (description);

		}
		break;

	case CHECK_INSTANCES:

		if (value_list==NULL)
			output_message = strdup (_("No Perfomance counter Category specified"));
		else {
			preparelist(value_list);
 			asprintf(&send_buffer,"%s&10&%s", req_password,value_list);
 			fetch_data (server_address, server_port, send_buffer);
 			asprintf (&output_message, "%s", recv_buffer);
 			return_code = STATE_OK;
		}
		break;

	case CHECK_EVENTLOG:

		if (value_list==NULL)
			asprintf(&send_buffer,"%s&11", req_password);
		else {
			asprintf(&send_buffer,"%s&11&%s", req_password,value_list);
		}
		fetch_data (server_address, server_port, send_buffer);
		return_code=atoi(strtok(recv_buffer,"&"));
		temp_string=strtok(NULL,"&");
		if(check_critical_value==TRUE &&  return_code >= critical_value)
			return_code=STATE_CRITICAL;
		else if (check_warning_value==TRUE && return_code >= warning_value)
			return_code=STATE_WARNING;	
		else if (check_warning_value==TRUE || check_critical_value==TRUE) 
			return_code=STATE_OK;	
		else if ( return_code == 0 )
			return_code = STATE_OK;
		else if ( return_code != STATE_OK )
			return_code=STATE_CRITICAL;
		output_message = strdup (temp_string);
		break;

	
	case CHECK_WMICHECK:

		if (value_list==NULL)
			output_message = strdup (_("No Query specified"));
		else {
			preparelist2(value_list,'^');
			asprintf(&send_buffer, "%s&12&%s", req_password,value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_CONFIG:

		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);/* replace , between parameters with & to send the request */
			asprintf(&send_buffer,"%s&99&%s", req_password,value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case ENUM_CONFIG:
		asprintf(&send_buffer,"%s&18", req_password);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case ENUM_PASSIVE:
		asprintf(&send_buffer,"%s&19", req_password);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CONFIG_DELPASSIVE:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&97&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			return_code=atoi(strtok(recv_buffer,"&"));
			temp_string=strtok(NULL,"&");
			output_message = strdup (temp_string);
		}
		break;

	case ENUM_PROCESS:
		asprintf(&send_buffer,"%s&17", req_password);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case ENUM_SERVICE:
		
		if ( value_list == NULL )
			asprintf(&send_buffer,"%s&16&all", req_password);
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&16&%s", req_password,value_list);
		}
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case ENUM_COUNTER:
		if ( value_list == NULL )
			asprintf(&send_buffer,"%s&15", req_password);
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&15&%s", req_password,value_list);
		}
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CHECK_WMICOUNTER:
		/* requires -d input showall for checking against max showfail check against min */
		if (value_list==NULL)
			output_message = strdup (_("No Query specified"));
		else {
			preparelist2(value_list,'^');
			if ( show_all == FALSE ) /*&& warning_value > critical_value )*/
				asprintf(&send_buffer, "%s&14&SHOWFAIL&%s", req_password,value_list);
			else asprintf(&send_buffer, "%s&14&SHOWALL&%s", req_password,value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			counter_value =atof(output_message);
			return_code = STATE_OK;
			if ( show_all == TRUE ) { /* returned a max value*/
				asprintf (&output_message, "%s \n%f Showall ", output_message, counter_value);
				if (check_warning_value == TRUE && counter_value >= atof(warning_value_string) ){
	    			return_code = STATE_WARNING;
				}
				if (check_critical_value == TRUE && counter_value >= atof(critical_value_string)){
	    		    return_code = STATE_CRITICAL;
				}
			}else {  /* returned a min value */
				asprintf (&output_message, "%s \n%f Showfail ", output_message, counter_value );
				if (check_warning_value == TRUE && counter_value <= atof(warning_value_string) ){
	    			return_code = STATE_WARNING;
				}
				if (check_critical_value == TRUE && counter_value <= atof(critical_value_string) ){
	    		     return_code = STATE_CRITICAL;
				}
			}
		}
		break;

	case ENUM_COUNTERDESC:
		if ( value_list == NULL )
			output_message = strdup (_("-l missing, no category specified."));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&20&%s", req_password,value_list);
		}
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CHECK_WMICAT:

		if (value_list==NULL)
			output_message = strdup (_("No Query specified"));
		else {
			preparelist2(value_list,'^');
			asprintf(&send_buffer, "%s&21&%s", req_password,value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_RUNSCRIPT :
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&101&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			return_code=atoi(strtok(recv_buffer,"&"));
			temp_string=strtok(NULL,"&");
			/* now check for thresholds befor submitting */
			/*Qustion should retun code from script overider threshold : */

			output_message = strdup (temp_string);
		}
		break;

	case ENUM_SCRIPT:
			asprintf(&send_buffer,"%s&102", req_password);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		break;

	case CONFIG_COPYSCRIPT:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&103&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;
	
	case CONFIG_DELSCRIPT:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&104&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CONFIG_ADDSCRIPT:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&105&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_CLIENTTIME:
		asprintf(&send_buffer,"%s&22", req_password);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CHECK_GETALLCHECKS:
		asprintf(&send_buffer,"%s&50", req_password);
		fetch_data (server_address, server_port, send_buffer);
		return_code=atoi(strtok(recv_buffer,"&"));
		temp_string=strtok(NULL,"&");
		output_message = strdup (temp_string);
		break;

	case CHECK_GETCHECK:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&51&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			/*output needs to be handled properly*/
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case ENUM_CHECK:
		asprintf(&send_buffer,"%s&52", req_password);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CONFIG_DELCHECK:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&53&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_GETCHECKTIME:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&54&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;
	case CHECK_CONFIG_BLIND: 
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);/* replace , between parameters with & to send the request */
			asprintf(&send_buffer,"%s&100&%s", req_password,value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_COMMAND_ENUM:
		asprintf(&send_buffer,"%s&106", req_password);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CHECK_COMMAND_COPY:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&107&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_COMMAND_DEL:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&108&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_COMMAND_PRINT:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&109&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_RUNSCRIPT_S:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&110&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			return_code=atoi(strtok(recv_buffer,"&"));
			temp_string=strtok(NULL,"&");
			output_message = strdup (temp_string);
		}
		break;

	case CHECK_CHANGEPASS:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&2000&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_ECHO:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			preparelist(value_list);
			asprintf(&send_buffer,"%s&2003&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_RUN_CMD_FILE:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&2004&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_RUNSCRIP_RAW_S:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&2006&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_EVENTLOG_NEW:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&2009&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			/* Result is # of events found followed by eventIDs */
			return_code=atoi(strtok(recv_buffer,"&"));
			temp_string=strtok(NULL,"&");
			if(check_critical_value==TRUE &&  return_code >= critical_value)
				return_code=STATE_CRITICAL;
			else if (check_warning_value==TRUE && return_code >= warning_value)
				return_code=STATE_WARNING;	
			else if (check_warning_value==TRUE || check_critical_value==TRUE) 
				return_code=STATE_OK;	
			else if ( return_code == 0 )
				return_code = STATE_OK;
			else if ( return_code != STATE_OK )
				return_code=STATE_CRITICAL;
			output_message = strdup (temp_string);
		}
		break;

	case CHECK_GETALLCHECK_2:
		asprintf(&send_buffer,"%s&2010", req_password, value_list);
		fetch_data (server_address, server_port, send_buffer);
		asprintf (&output_message, "%s", recv_buffer);
		return_code = STATE_OK;
		break;

	case CHECK_WMICAT_NEW:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&2016&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_RUNSCRIP_RAW_A:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&2029&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_OTHER:
		if (value_list==NULL)
			output_message = strdup (_("missing -l parameters"));
		else {
			asprintf(&send_buffer,"%s&%s", req_password, value_list);
			fetch_data (server_address, server_port, send_buffer);
			asprintf (&output_message, "%s", recv_buffer);
			return_code = STATE_OK;
		}
		break;

	case CHECK_NONE:
	default:
		usage4 (_("Please specify a variable to check"));
		break;

	}

	/* reset timeout */
	alarm(0);

	if (perfdata==NULL)
		printf("%s\n",output_message);
	else
		printf("%s | %s\n",output_message,perfdata);
	return return_code;
}



/* process command-line arguments */
int process_arguments(int argc, char **argv){
	int c;

	int option = 0;
	static struct option longopts[] =
	{ 
		{"port",     required_argument,0,'p'},
		{"timeout",  required_argument,0,'t'},
		{"critical", required_argument,0,'c'},
		{"warning",  required_argument,0,'w'},
		{"variable", required_argument,0,'v'},
		{"addpassive", required_argument,0,'S'},
		{"hostname", required_argument,0,'H'},
		{"version",  no_argument,      0,'V'},
		{"alternate", no_argument,      0,'a'},
		{"help",     optional_argument,0,'h'},
		{0,0,0,0}
	};

	/* no options were supplied */
	if(argc<2) return ERROR;


	/* change default timeout to 20 seconds */
	socket_timeout = 20;

	/* backwards compatibility */
	if (! is_option(argv[1])) {
		server_address = strdup(argv[1]);
		argv[1]=argv[0];
		argv=&argv[1];
		argc--;
	}

  for (c=1;c<argc;c++) {
    if(strcmp("-to",argv[c])==0)
      strcpy(argv[c],"-t");
    else if (strcmp("-wv",argv[c])==0)
      strcpy(argv[c],"-w");
    else if (strcmp("-cv",argv[c])==0)
      strcpy(argv[c],"-c");
	}

	while (1){
		c = getopt_long(argc,argv,"+haVH:S:t:c:w:p:v:l:s:d:",longopts,&option);

		if (c==-1||c==EOF||c==1)
			break;

		switch (c)
			{
			case '?': /* print short usage statement if args not parsable */
			usage2 (_("Unknown argument"), optarg);
			case 'h': /* help */
				if ( optarg == NULL ) {
					print_help();
					exit(STATE_OK);
				} 
				else { /*print help on single command*/
					print_command(optarg);
					exit(STATE_OK);
				}
			case 'V': /* version */
				print_revision(progname,revision);
				exit(STATE_OK);
				
			case 'a': /* alternate */
				alternate_tcp_socket=TRUE;
				break;
			case 'H': /* hostname */
				if (server_address)	free(server_address);
				server_address = optarg;
				break;
			case 's': /* password */
				req_password = optarg;
				break;
			case 'p': /* port */
				if (is_intnonneg(optarg))
					server_port=atoi(optarg);
				else
					die(STATE_UNKNOWN,_("Server port must be an integer\n"));
				break;
			case 'S': /* service_descriptio */
				service_desc = optarg;
				add_passive_check = TRUE;
				break;
			case 'v':
				if(strlen(optarg)<4)
					return ERROR;
				check_type = optarg;
				if(!strcmp(optarg,"CLIENTVERSION"))
					vars_to_check=CHECK_CLIENTVERSION;
				else if(!strcmp(optarg,"CPULOAD"))
					vars_to_check=CHECK_CPULOAD;
				else if(!strcmp(optarg,"UPTIME"))
					vars_to_check=CHECK_UPTIME;
				else if(!strcmp(optarg,"USEDDISKSPACE"))
					vars_to_check=CHECK_USEDDISKSPACE;
				else if(!strcmp(optarg,"SERVICESTATE"))
					vars_to_check=CHECK_SERVICESTATE;
				else if(!strcmp(optarg,"PROCSTATE"))
					vars_to_check=CHECK_PROCSTATE;
				else if(!strcmp(optarg,"MEMUSE"))
					vars_to_check=CHECK_MEMUSE;
				else if(!strcmp(optarg,"COUNTER"))
					vars_to_check=CHECK_COUNTER;
				else if(!strcmp(optarg,"FILEAGE"))
					vars_to_check=CHECK_FILEAGE;
				else if(!strcmp(optarg,"INSTANCES"))
					vars_to_check=CHECK_INSTANCES;
				else if(!strcmp(optarg,"EVENTLOG"))
					vars_to_check=CHECK_EVENTLOG;
				else if(!strcmp(optarg,"WMICHECK"))
					vars_to_check=CHECK_WMICHECK;
				else if(!strcmp(optarg,"FREEDISKSPACE"))
					vars_to_check=CHECK_FREEDISKSPACE;
				else if(!strcmp(optarg,"CONFIG"))
					vars_to_check=CHECK_CONFIG;
				else if(!strcmp(optarg,"ENUMCONFIG"))  
					vars_to_check=ENUM_CONFIG;
				else if(!strcmp(optarg,"ENUMPASSIVE"))  
					vars_to_check=ENUM_PASSIVE;
				else if(!strcmp(optarg,"DELPASSIVE"))  
					vars_to_check=CONFIG_DELPASSIVE;
				else if(!strcmp(optarg,"ENUMPROCESS"))  
					vars_to_check=ENUM_PROCESS;
				else if(!strcmp(optarg,"ENUMSERVICE"))  
					vars_to_check=ENUM_SERVICE;
				else if(!strcmp(optarg,"WMICOUNTER"))  
					vars_to_check=CHECK_WMICOUNTER;
				else if(!strcmp(optarg,"ENUMCOUNTER"))  
					vars_to_check=ENUM_COUNTER;
				else if(!strcmp(optarg,"ENUMCOUNTERDESC"))  
					vars_to_check=ENUM_COUNTERDESC;
				else if(!strcmp(optarg,"WMICAT"))  
					vars_to_check=CHECK_WMICAT;
				else if(!strcmp(optarg,"RUNSCRIPT"))  
					vars_to_check=CHECK_RUNSCRIPT;
				else if(!strcmp(optarg,"ENUMSCRIPT"))  
					vars_to_check=ENUM_SCRIPT;
				else if(!strcmp(optarg,"COPYSCRIPT"))  
					vars_to_check=CONFIG_COPYSCRIPT;
				else if(!strcmp(optarg,"DELSCRIPT"))  
					vars_to_check=CONFIG_DELSCRIPT;
				else if(!strcmp(optarg,"ADDSCRIPT"))  
					vars_to_check=CONFIG_ADDSCRIPT;
				else if(!strcmp(optarg,"CLIENTTIME"))  
					vars_to_check=CHECK_CLIENTTIME;
				else if(!strcmp(optarg,"GETALLCHECKS"))  
					vars_to_check=CHECK_GETALLCHECKS;
				else if(!strcmp(optarg,"GETCHECK"))  
					vars_to_check=CHECK_GETCHECK;
				else if(!strcmp(optarg,"ENUMCHECK"))  
					vars_to_check=ENUM_CHECK;
				else if(!strcmp(optarg,"DELCHECK"))  
					vars_to_check=CONFIG_DELCHECK;
				else if(!strcmp(optarg,"GETCHECKTIME"))  
					vars_to_check=CHECK_GETCHECKTIME;
				else if(!strcmp(optarg,"CONFIG_BLIND"))  
					vars_to_check=CHECK_CONFIG_BLIND;
				else if(!strcmp(optarg,"COMMAND_ENUM"))  
					vars_to_check=CHECK_COMMAND_ENUM;
				else if(!strcmp(optarg,"COMMAND_COPY"))  
					vars_to_check=CHECK_COMMAND_COPY;
				else if(!strcmp(optarg,"COMMAND_DEL"))  
					vars_to_check=CHECK_COMMAND_DEL;
				else if(!strcmp(optarg,"COMMAND_PRINT"))  
					vars_to_check=CHECK_COMMAND_PRINT;
				else if(!strcmp(optarg,"RUNSCRIPT_S"))  
					vars_to_check=CHECK_RUNSCRIPT_S;
				else if(!strcmp(optarg,"CHANGEPASS"))  
					vars_to_check=CHECK_CHANGEPASS;
				else if(!strcmp(optarg,"ECHO"))  
					vars_to_check=CHECK_ECHO;
				else if(!strcmp(optarg,"RUN_CMD_FILE"))  
					vars_to_check=CHECK_RUN_CMD_FILE;
				else if(!strcmp(optarg,"RUNSCRIP_RAW_S"))  
					vars_to_check=CHECK_RUNSCRIP_RAW_S;
				else if(!strcmp(optarg,"EVENTLOG_NEW"))  
					vars_to_check=CHECK_EVENTLOG_NEW;
				else if(!strcmp(optarg,"GETALLCHECK_2"))  
					vars_to_check=CHECK_GETALLCHECK_2;
				else if(!strcmp(optarg,"WMICAT_NEW"))  
					vars_to_check=CHECK_WMICAT_NEW;
				else if(!strcmp(optarg,"RUNSCRIP_RAW_A"))  
					vars_to_check=CHECK_RUNSCRIP_RAW_A;
				else if(!strcmp(optarg,"OTHER"))  
					vars_to_check=CHECK_OTHER;
				else
					return ERROR;
				break;
			case 'l': /* value list */
				value_list = optarg;
				break;
			case 'w': /* warning threshold */
				warning_value_string = optarg;
				warning_value=strtoul(optarg,NULL,10);
				check_warning_value=TRUE;
				break;
			case 'c': /* critical threshold */
				critical_value_string = optarg;
				critical_value=strtoul(optarg,NULL,10);
				check_critical_value=TRUE;
				break;
			case 'd': /* Display select for services; Cooser for smallest in WMICOUNTER*/
				if (!strcmp(optarg,"SHOWALL"))
					show_all = TRUE;
				break;
			case 't': /* timeout */
				socket_timeout=atoi(optarg);
				if(socket_timeout<=0)
					return ERROR;
			}
	}


	if (vars_to_check==CHECK_NONE)
		return ERROR;

	if (req_password == NULL)
		req_password = strdup (_("None"));

	return OK;
}



void fetch_data (const char *address, int port, const char *sendb) {
	int result;
   /*	 process_tcp_request2 may be used instead but not compatible with ns_client*/
	if(alternate_tcp_socket==FALSE)
		result=process_tcp_request(address, port, sendb, recv_buffer,sizeof(recv_buffer));
	else
		result=process_tcp_request3(address, port, sendb, recv_buffer,sizeof(recv_buffer));

	if(result!=STATE_OK)
		die (result, _("could not fetch information from server\n"));
		
	if (!strncmp(recv_buffer,"ERROR",5))
		die (STATE_UNKNOWN, "Client - %s\n",recv_buffer);/*changed from NSClient to be inclsive of NC_Net*/
}



int strtoularray(unsigned long *array, char *string, const char *delim) {
	/* split a <delim> delimited string into a long array */
	int idx=0;
	char *t1;

	for (idx=0;idx<MAX_VALUE_LIST;idx++)
		array[idx]=0;
	
	idx=0;
	for(t1 = strtok(string,delim);t1 != NULL; t1 = strtok(NULL, delim)) {
		if (is_numeric(t1) && idx<MAX_VALUE_LIST) {
			array[idx]=strtoul(t1,NULL,10);
			idx++;
		} else  
			return FALSE;
	}		
	return TRUE;
}

void preparelist(char *string) {
	/* Replace all , with & which is the delimiter for the request */
	int i;

	for (i = 0; (size_t)i < strlen(string); i++)
		if (string[i] == ',') {
			string[i]='&';
		}
}

void preparelist2(char *string, char c) {
	/* Replace all delimiter c  with & which is the delimiter for the request */
	int i;

	for (i = 0; (size_t)i < strlen(string); i++)
		if (string[i] == c) {
			string[i]='&';
		}
}


void print_help(void)
{
	print_revision(progname,revision);
	printf ("Copyright (c) 2007 Tony Montibello (tony@MontiTech.com)\n");
	printf ("Based on check_nt.c by\n");
	printf ("Copyright (c) 2000 Yves Rubin (rubiyz@yahoo.com)\n\n");
	printf (_("This plugin comunicates with the NSClient/NC_Net service running on a\n\
 Windows server.\n\n"));

	print_usage();
	
  printf (_("\nOptions:\n\
-H, --hostname=HOST\n\
  Name of the host to check\n\
-p, --port=INTEGER\n\
  Optional port number (default: %d)\n\
-s <password>\n\
  Password needed for the request\n\
-a, --alternate\n\
  Use alternate P Buffer sizes\n\
  This allows for recieving more than the default buffer limit of 1249\n\
  may not be compatible with NS_Client but OK for NC_NET\n\
  When using this option, some data may skip processing \n\
  and go directly to Standard Output\n\
-w, --warning=INTEGER\n\
  Threshold which will result in a warning status\n\
-c, --critical=INTEGER\n\
  Threshold which will result in a critical status\n\
-t, --timeout=INTEGER\n\
  Seconds before connection attempt times out (default: %d)\n\
-h, --help=STRING\n\
  Print Command specific help\n\
-V, --version\n\
  Print version information\n"), PORT, 20);
	
  printf (_("\
-v, --variable=STRING\n\
  Variable to check.  Valid variables are:\n\
  Use --help=<check_variable_name> -- to list help for that command.\n"));

  printf (_("\
   CLIENTVERSION = Get the Check_nt version Number\n\
   CPULOAD = Average CPU load on last x minutes.\n\
   UPTIME = Get the uptime of the machine.\n\
   USEDDISKSPACE = check Size(in Megs) or percentage of disk use.\n\
   FREEDISKSPACE = check Size(in Megs) or percentage of disk free.\n\
   MEMUSE = Memory use.\n\
   SERVICESTATE = Check the state of one or several services.\n\
   PROCSTATE = Check if one or several process are running.\n\
   COUNTER = Check any performance counter of Windows NT/2000.\n\
   FILEAGE = Checks how old a file is .\n\
   INSTANCES = Check any performance counter Category for availible instances.\n\
   EVENTLOG = Check any Event Log in Windows for any entry.\n\
   WMICHECK = performs a WMI query on Windows server.\n\
   WMICOUNTER = Checks -w -c against a specific querry\n\
   WMICAT = Runs WMI Query and outputs Concatinated results\n\
   CONFIG = push a configuration variable change to NC_Net via active checks.\n\
   ENUMCONFIG = Prints NC_Net's configuration.\n\
   ENUMPASSIVE = Print out list of service descriptions from passive.cfg\n\
   DELPASSIVE = Deletes a passive check from NC_Net passive.cfg.\n\
   ENUMCOUNTER = Enumerates performance counters.\n\
   ENUMCOUNTERDESC = Prints the internal detailed description of a performance counter.\n\
   ENUMSERVICE = Print out list of all services\n\
   ENUMPROCESS = Prints all running processes.\n\
   ENUMSCRIPT = Prints a list of files loaded in NC_Net script directory\n\
   RUNSCRIPT = Runs a script loaded in NC_Net Script Directory (Asyncronous)\n\
   ADDSCRIPT = Uploads a script into NC_Net Script Directory\n\
   DELSCRIPT = Deletes a file in the NC_Net Script Directory\n\
   COPYSCRIPT = Copies a file in the NC_Net Script Directory to a new file name\n\
   CLIENTTIME = Gets the System time form the client Host.\n\
   GETALLCHECKS = Gets the stored Service checks. (Passive checks must be running)\n\
   GETCHECK = Get a stored check result form the client.\n\
   ENUMCHECK = Comma seeperated list of stored checks on the client.\n\
   DELCHECK = removes a check from the stored check.(run DELPASSIVE seperatly)\n\
   GETCHECKTIME = gets the time that a stored check was preformed.\n\
   COMMAND_ENUM	= prints a list of the files names in the command directory\n\
   COMMAND_COPY	= copys one file to a new filename in the command directory\n\
   COMMAND_DEL = delets a file in the command directory\n\
   COMMAND_PRINT = Prints the content of a file in the command directory\n\
   RUNSCRIPT_S = Runs a script loaded in NC_Net Script Directory (Syncronous)\n\
   CHANGEPASS = Command used to Change the Password Remotly.\n\
   ECHO = Command returns the -l input.\n\
   RUN_CMD_FILE = Command used to run a file configured with checks to process\n\
   RUNSCRIP_RAW_S = Runs a script loaded in NC_Net Script Directory (Syncronous)(Always OK)\n\
   EVENTLOG_NEW	= Optimized Command used to do a query againt the Event Logs\n\
   GETALLCHECK_2 = Command used to get all PREFETCHED_DATA configured through Passive checks.\n\
   WMICAT_NEW = newer version of WMICAT where output is a paired with Data Labels. \n\
   RUNSCRIP_RAW_A- Runs a script loaded in NC_Net Script Directory (Asyncronous)(Always OK)\n\
   OTHER = Makes -l function as the test conole. \n\
\n\
   ADDPASSIVE = Add a passive check to passive.cfg.\n\
     DO NOT use -v ADDPASSIVE  \n\
	 Instead run the desired passive check as an active check from the command line.\n\
	 then after you tested the command add the switch -S <service description>  \n\
	 (NOTE this is a capital S) \n"));
  printf (_("\
-S --addpassive=STRING\n\
  the STRING should be the Nagios service description. (unique for each host)\n\
   This option is used primarily to add a passive check to NC_Net's passive.cfg.\n\
   Active checks do not require the service description. \n\
   When this option is added to a service check it will send the check as an addition \n\
   to the passive.cfg.  This test will verify the check will return an OK result. \n\
   If the check does not return OK the check will not be added or modified to passive.cfg\n"));

  printf (_("Notes:\n\
 - NC_Net should be running.  \n\
   NC_Net@MontiTech.com \n\
   (http://sourceforge.net/projects/nc-net).\n"));
 }



void print_usage(void)
{
	printf("\
		   Usage: %s -H host -v variable [-p port] [-w warning] [-c critical]\n\
                [-l params] [-d SHOWALL] [-t timeout] [-S Service_description]\n\
				[-a] [-h helpCommand] [-V] [-s password] ", progname);
}

void print_command_CLIENTVERSION(void){
  printf (_("\
   CLIENTVERSION = Get the NSClient version\n\
     If -l <version> is specified, will return warning if versions differ.\n"));
}
void print_command_CPULOAD(void){
  printf (_("\
   CPULOAD = Average CPU load on last x minutes.\n\
     Request a -l parameter with the following syntax:\n\
     -l <minutes range>,<warning threshold>,<critical threshold>.\n\
     <minute range> should be less than 24*60.\n\
     Thresholds are percentage and up to 10 requests can be done in one shot.\n\
     ie: -l 60,90,95,120,90,95\n"));
}
void print_command_UPTIME(void){ printf (_("\
   UPTIME = Get the uptime of the machine.\n\
     No specific parameters. No warning or critical threshold\n"));
 }
void print_command_USEDDISKSPACE(void){ printf (_("\
   USEDDISKSPACE = Size and percentage of disk use.\n\
     Request a -l parameter containing the drive letter only.\n\
     Thresholds can be specified (in precentage used) with -w and -c.\n\
	 When the warning or critical value is less than 100 it is evaluated as a percentage of space.\n\
	 When the warning or critical value are above 100 they are evaluated as MegaBytes.\n"));	 
 }
void print_command_FREEDISKSPACE(void){ printf (_("\
   FREEDISKSPACE = Size and percentage of disk use.\n\
     Request a -l parameter containing the drive letter only.\n\
     Thresholds can be specified (in megabytes free) with -w and -c.\n\
	 When the warning or critical value is less than 100 it is evaluated as a percentage of space.\n\
	 When the warning or critical value are above 100 they are evaluated as bytes.\n\
	 Warning and critical are Integers and therfore limited to numbers less than 4 gigs.\n"));

 }
void print_command_MEMUSE(void){ printf (_("\
   MEMUSE = Memory use.\n\
     Warning and critical thresholds can be specified with -w and -c.\n"));
 }
void print_command_SERVICESTATE(void){ printf (_("\
   SERVICESTATE = Check the state of one or several services.\n\
     Request a -l parameters with the following syntax:\n\
     -l <service1>,<service2>,<service3>,...\n\
     You can specify -d SHOWALL in case you want to see working services\n\
     in the returned string.\n"));
  }
void print_command_PROCSTATE(void){ printf (_("\
   PROCSTATE = Check if one or several process are running.\n\
     Same syntax as SERVICESTATE.\n"));
  }
void print_command_COUNTER(void){ printf (_("\
   COUNTER = Check any performance counter of Windows.\n\
     This check accepts -w and -c\n\
     Request a -l parameters with the following syntax:\n\
	 -l \"\\\\<performance object>\\\\counter\"[,\"<Label>\"][,<UOM>][,<MIN>][,<MAX>]\n\
	 from the command line single \\ works.\n\
	 COUNTER NOW OVERLOADED To also use the following format\n\
	 -l \"^COUNTERCATEGORY^INSTANCE^CounterNAME\"[,\"<Label>\"][,<UOM>][,<MIN>][,<MAX>]\n\
	 -l \"^COUNTERCATEGORY^CounterNAME\"[,\"<Label>\"][,<UOM>][,<MIN>][,<MAX>]\n\
	 Must have performance category and instance encapsulated in \\\n\
      the first parameter is the counter that is sent to NC_Net.\n\
	  use $$ instead of $ \n\
	  the rest of the parameters are for performance data only.\n\
	  older version of NC_Net used the label for formating\n\
	  the counter should be in the format of:\n\
	  \"\\category(Instance)\\counter\"\n\
	  please keep this in Quotes for consistancy \n\
	  category is the performance counter category \n\
	  Instance is in parenthases if no instance for the category then leave out.\n\
	  Do not use empty parenthases.\n\
	  the counter is the performance counter's countner.\n\
	  Automatic detection of %% is done only against the performance counter\n\
	    it is no longer done against the entier -l option.\n\
	  label is the label for performance data\n\
	  If the label is omited then the performance counter object will be used.\n\
	  UOM - Unit of Measurment -if no UOM use a zero 0, \n\
	  a zero tells check_nt to ignore the UOM in the output.\n\
	  examples of UOM- s,us,ms,%%,B,KB,MB,TB,c \n\
      c- is for continous counter. \n\
	  Min and Max are optional but are used by third party program (RRD) for graphing.\n\
	 Some examples:\n\
	-l \"\\Process(_Total)\\Thread Count\",\"Thread Count\",MB,0,1000 -w 5 -c 700\n\
	Thread Count = 534.00 MB | 'Thread Count'=534.000000MB;5.000000;700.000000;0.000000;1000.000000\n\
        -l \"\\Paging File(_Total)\\%% Usage\"\n\
	\\Paging File(_Total)\\%% Usage = 36.61 %%\n\
        -l \"\\paging file(_total)\\%% usage\"\n\
	\\paging File(_total)\\%% usage = 36.61 %%\n\
        -l \"\\paging file(_total)\\%% usage\",\"test1\"\n\
	test1 = 36.60 % | test1=36.599730%;;;0.000000;100.000000\n\
        -l \"\\paging file(_total)\\%% usage\",\"test1\",%%,20\n\
	test1 = 36.60 % | test1=36.599730%;;;20.000000;100.000000\n\
	-l \"\\Server\\Server Sessions\",\"test SS\",%%\n\
	test SS = 1.00 %% | 'test SS'=1.000000%%;;;\n\
	-l  \"\\Server\\Server Sessions\",\"Server Sessions\",0,0,50 -w 20 -c 45\n\
	Server Sessions = 1.00 c | 'Server Sessions'=1.000000;20.000000;45.000000;0.000000;50.000000\n"));

 }
void print_command_FILEAGE(void){ printf (_("\
   FILEAGE = Checks how old a file is .\n\
     Request a -l parameters with the following syntax:\n\
     -l \"<File path>\\\\<File Name>\"\n\
     Warning and critical thresholds can be specified with -w and -c.\n")); 
 }
void print_command_INSTANCES(void){ printf (_("\
   INSTANCES = Check any performance counter Category for availible instances.\n\
     Request a -l parameters with the following syntax:\n\
     -l <Perfomance Counter Category>,<Perfomance Counter Category>,...\n\
     Does not use -w or -c,\n\
     returns a list of Instances for each Category in the list of categories.\n\
     example:\n\
     -l \"Memory,Process,Print Queue\"\n"));
  }
void print_command_EVENTLOG(void){printf (_("\
   EVENTLOG = Check any Event Log in Windows for any entry.\n\
     Request a -l parameters with the following syntax:\n\
     -l \"<Event Log>,<Event Type>,<minutes range>,\n\
         <Source Filter list>,<Message Filter List>,<Event ID Filter List>\"\n\
     <Event Log> - any, System, Application, Security \n\
         or any other non-standard Event Log. 'any' will check all logs.\n\
     <Event Type> - any, Information, Warning, Error,\n\
         or other non-standard Event Type. 'any' will check all Types.\n\
     <minutes range> - Maximum age in minutes of event entries to check.\n\
         Use 0 to check all event Entries in log.\n\
     <Source Filter List> Use 0 to diable the Source Filter.\n\
         Otherwise enter a comma seperated list \n\
         with the first element being the number of items in the list.\n\
         Use a negitive number to Exclude matching entries.\n\
         Use a positive number to Include only matching entries.\n\
     <Message Filter List> Use 0 to diable the Message Filter.\n\
         (Message Filter accepts Regular Expressions) \n\
         Otherwise enter a comma seperated list \n\
         with the first element being the number of items in the list.\n\
         Use a negitive number to Exclude matching entries.\n\
         Use a Positive number to Include only matching entries.\n\
     <Event ID Filter List> Use 0 to diable the Event ID Filter.\n\
         Otherwise enter a comma seperated list with the first element\n\
         being the number of items in the list.\n\
         Use a negitive sign to Exclude matching entries.\n\
         Use a positive number to Include only matching entries.\n\
     Examples:\n\
         The Following examples will list all events in the System Event Log\n\
         that have a source of eventlog and have the word start or stop\n\
         withing the event message.\n\
         -l \"System,any,0,1,eventlog,2,start,stop,0\"\n\
         -l \"System,any,0,1,eventlog,1,(start|stop),0\"\n"));
 }
void print_command_WMICAT(void) { printf (_("\
   WMICAT = Performs a WMI query on a Windows server\n\
     and returns a concatinated result of the querry as output.\n\
	 This check always returns OK if the query is valid.\n\
	 This check return Warning or Critical if the query fails.\n\
	 This check uses the -l in the same format as WMICHECK.\n\
	 for more details of the -l syntex run --help=WMICHECK\n"));
}
void print_command_WMICHECK(void){ printf (_("\
   WMICHECK = performs a WMI query on Windows server.\n\
   NOTE: the -l parameter must be within quotes \" \n\
     WMI needs to be installed on pre 2000, and Win 9x \n\
	  this command should be run from commandline only \n\
	 USE WMICOUNTER for active check of WMI value (\n\
     Reqires -l parameters with the following syntax:\n\
     -l \"<Namespace>[ [^<Select>|^<FULL SELECT>][^<CLass>][^<condition>] ]\"\n\
     basicly this command does a query to WMI. \n\
     the syntex is fairly loose and the return string typicly has linefeeds in it.\n\
     basic command is -l \"Namespace^Full select statment\" \n\
     the select stament can also be tokenized into seperate parameters as displayed in these examples:\n\
     Example inputs- \n\
     * - list all namespaces \n\
     namespace^* - list all classes in namespace \n\
     namespace^ full querry statment - enter a full querry statment as second parameter\n\
     namespace^*^class - list all instances in class \n\
     namespace^select^class - list specific selected data from all class instances \n\
     \n\
     -l command structure overview\n\
     namespace^select^class^where - \n\
     examples: \n\
     * \n\
     cimv2^* \n\
     cimv2^SELECT Size,Name From win32_logicaldisk where name = 'c:' \n\
     cimv2^size,name^win32_logicaldisk \n\
     cimv2^size,name^win32_logicaldisk^name= 'c:' \n\
     Note: win32_logicaldisk access the floppy drives during processing.\n"));
  }
void print_command_CONFIG(void){ printf (_("\
   CONFIG = push a configuration variable change to NC_Net via active checks.\n\
     this command should be run from commandline only\n\
	 Request a -l parameters with the following syntax:\n\
	 -l \"<NC_Net variable>,<Value> \"\n\
	  Changes a configuration value to the current running config of NC_Net\n\
	  This can be used to modify all vairibles that are assesable via startup.cfg\n\
	  Use this option with care because it may induce problems \n\
	  (not all dynamic changes have been configured yet\n\
	  To make NC_Net regect this command set lock_active_config to true\n\
	"));
 }
void print_command_ENUMCONFIG(void){ printf (_("\
   ENUMCONFIG = Prints NC_Net's configuration.\n\
     No specific parameters. No warning or critical threshold\n\
     this command should be run from commandline only\n"));
 }
void print_command_ENUMPASSIVE(void){ printf (_("\
   ENUMPASSIVE = Print out list of service descriptions from passive.cfg\n\
     this command should be run from commandline only\n\
     No specific parameters. No warning or critical threshold.\n"));
  }
void print_command_DELPASSIVE(void){ printf (_("\
   DELPASSIVE = Deletes a passive check from NC_Net passive.cfg.\n\
     this command should be run from commandline only\n\
     Request a -l parameters with the following syntax:\n\
     -l <Service description>\n"));
 }
void print_command_ENUMCOUNTER(void){ printf (_("\
   ENUMCOUNTER = Enumerates performance counters.\n\
     No warning or critical threshold\n\
	 this command should be run from commandline only\n\
	 if -l is ommited the return list will be of perfomance counter Categories. Otherwise\n\
	 -l <performance counter Category>[,<performance counter Category>]\n\
     returns a list of  counters for the specified categories.\n"));
 }   
void print_command_ENUMCOUNTERDESC(void){ printf (_("\
   ENUMCOUNTERDESC = Prints a performance counter's internal detailed description.\n\
     No warning or critical threshold\n\
	 this command should be run from commandline only\n\
	 -l <performance counter Category>[,<performance counter>]\n\
	 -l is comma seperated.  If Counter is ommited it will print the description of the Category.\n"));
 }
void print_command_ENUMSERVICE(void){  printf (_("\
   ENUMSERVICE = Print out list of all services\n\
     No warning or critical threshold.\n\
	 this command should be run from commandline only\n\
     Request a -l parameters with the following syntax:\n\
     -l <type>[,short]\n\
     <type> is the type of Services to enumerate:\n\
     all		- enumerate all found services\n\
     short	- list short names only (default will print descriptive names)\n\
     running	- list all runnning services\n\
     stopped	- list all NOT running services\n\
     automatic- list all services setup for automatic startup type\n\
     manual	- list all services setup for manual startup type\n\
     disabled - list all services that are disabled.\n"));
 } 
void print_command_ENUMPROCESS(void){ printf (_("\
   ENUMPROCESS = Prints all running processes.\n\
     No specific parameters. No warning or critical threshold\n\
     this command should be run from commandline only\n"));
 } 
void print_command_ADDPASSIVE(void){  printf (_("\
   ADDPASSIVE = Add a passive check to passive.cfg.\n\
     DO NOT use -v ADDPASSIVE \n\
	 Instead run the desired passive check as an active check from the command line.\n\
	 then after you tested the command add the switch -S <service description>  \n\
	 (NOTE this is a capital S) \n"));
  printf (_("\
   -S --addpassive=STRING\n\
     the STRING should be the Nagios service description. (unique for each host)\n\
     This option is used primarily to add a passive check to NC_Net's passive.cfg.\n\
     Active checks do not require the service description. \n\
     When this option is added to a service check it will send the check as an addition \n\
     to the passive.cfg.  This test will verify the check will return an OK result. \n\
     If the check does not return OK the check will not be added or modified to passive.cfg\n"));
}
void print_command_WMICOUNTER(void){ printf (_("\
   WMICOUNTER = Checks -w or -c against a WMI query result.\n\
     This requires the -d showall to check for max value ( critical if result greater than -c-w)\n\
	 The -d SHOWFAIL will check against a min value (critical if result less than -c -w )\n\
     Then the results will be compared to the warning and critical values.\n\
     WMI has a lot of System data stored within it.\n\
     For more information of using WMI see the WMI Development Kit (Free) available from Microsoft.\n\
	 This check uses the same structure as the WMICHECK. \n\
	 Before using this WMICounter validate that the query work correctly using WMICHECK. \n\
	 It is preferred that each query resolves only to a single object instance being returned.\n\
	 However if more than one object is found the largest value will be returned \n\
	 and compared to the warning and critical values. \n\
	 (using WMICOUNTER against multiple objects can be handy \n\
	 for comparing if any surpass the trigger values.) \n\
     -d showfail is used internally in check_nt and NC_Net for this service check.\n\
	 It is used to indicate that the smallest value should be returned instead of the largest.\n\
	 You can explicity declare that the check will return an alert when less than the -c or -w \n\
	 By using -d SHOWFAIL\n\
	 Care should be used when returning the smallest in case the query has some zeros values being returned.\n\
	 All values will be converted to doubles during processing, \n\
	 this is to simplify the fact that the result can be of any type (double, integer, long, percent) \n"));
 }
void print_command_RUNSCRIPT(void){  printf (_("\
   RUNSCRIPT = Runs a external script of program stored in the script folder of NC_Net. \n\
     this command Does not use -w or -c thresholds. \n\
	 -l \"<Scriptname> <args>\" \n\
	 Note: command does not accept & in the command \n\
     This command requires that allow_run_scripts is set to true in startup.cfg of NC_Net. \n\
	 This command requires that do_not_blaim_nc_net to be set to true if you want to pass \n\
	 command line arguments to the script.  If do_not_blaim_nc_net is false everything after \n\
	 the first whitespace will be removed from the command.  This command will only run the scripts\n\
	 that are in the script folder of NC_Net.  It will regect any commands that contain \n\
	 a .. in the filename.  if the script_timeout from startup.cfg is surpassed the script \n\
	 will be killed, and an error is returned.  Otherwise the REsturn code and standard output \n\
	 of the script is retuned.\n"));
 }
void print_command_ENUMSCRIPT(void){  printf (_("\
   ENUMSCRIPT = Will print a comma seperated list of availible scripts.\n\
     THis command does not have a -l\n"));
 }
void print_command_COPYSCRIPT(void){  printf (_("\
   COPYSCRIPT = Will copy a script in the script folder to a new file.\n\
     This command requires that allow_run_scripts is set to true in startup.cfg of NC_Net. \n\
     -l <Source file>,<Destination file>\n"));
 }
void print_command_DELSCRIPT(void){  printf (_("\
   DELSCRIPT = Will delete a file from the script directory.\n\
     This command requires that allow_run_scripts is set to true in startup.cfg of NC_Net. \n\
     -l <SCRIPTNAME> \n\
\n"));
 }
void print_command_ADDSCRIPT(void){  printf (_("\
   ADDSCRIPT = This command is used to upload a script to NC_NET. \n\
     This command requires that allow_run_scripts is set to true in startup.cfg of NC_Net. \n\
	 THIS COMMAND IS NOT YET IMPLEMENTED.\n"));
 }

void print_command_CLIENTTIME(void){ printf (_("\
   CLIENTTIME = This command will get the time from the remote host.\n\
\n"));
 }

void print_command_GETALLCHECKS(void){ printf (_("\
   GETALLCHECKS = This command will retrieve all the stored checks for the remote host.\n\
     Configured Passive checks in NC_Net are automatically stored.\n\
     No specific parameters. No Warning or Critical threshold.\n\
     When a check contains the same service description the oldes will be overwriten.\n\
     This check will return OK if all checks are OK.\n\
     This check will return Critical if any of the checks are critical.\n\
     This check will return Warning when there are warnings and no criticals.\n\
     The output will consist of a list of Critical and Warnings. \n\
     as well as the performance data from all the checks.\n\
\n"));
 }

void print_command_GETCHECK(void){ printf (_("\
   GETCHECK = This command will retrive service check results stored in NC_Net.\n\
     Configured Passive checks in NC_Net are automatically stored.\n\
     -l <service description>,<service description>,...\n\
      the -l is a comma delimited list of service descriptions.\n\
      The results are similare to GETALLCHECKS.\n\
\n"));
 }

void print_command_ENUMCHECK(void){ printf (_("\
   ENUMCHECK = This command prints a comma delimited list of stored check names from NC_Net.\n\
     No specific parameters. No Warning or Critical threshold.\n\
\n"));
 }

void print_command_DELCHECK(void){ printf (_("\
   DELCHECK = This check will delete a stored chck form NC_Net.\n\
     -l <service description>,<service description>,...\n\
      The -l is a comma delimited list of service descriptions to delete from NC_Net.\n\
\n"));
 }

void print_command_GETCHECKTIME(void){ printf (_("\
   GETCHECKTIME = This command will retrive the time from specific stored checks.\n\
     -l <service description>,<service description>\n\
      The -l is a comma delimited list of service descriptions.\n\
      The Time is the time that the service check was run on NC_Net.\n\
\n"));
 }
void print_command_CONFIG_BLIND(void){ printf (_("\
   CONFIG_BLIND = This command is the same as the command CONFIG\n\
     However it is not ment for use from Check_nc_net\n\
	  It is to be used inside a Command File.\n\
\n"));
 }

void print_command_COMMAND_ENUM(void){ printf (_("\
   COMMAND_ENUM = Will print a comma seperated list of availible Command files.\n\
     THis command does not have a -l\n\
\n"));
 }

void print_command_COMMAND_COPY(void){ printf (_("\
   COMMAND_COPY = Will copy a Command file in the command folder to a new file.\n\
     -l <Source file>,<Destination file> \n\
\n"));
 }

void print_command_COMMAND_DEL(void){ printf (_("\
   COMMAND_DEL = Will delete a file from the command directory.\n\
     -l <Filename> \n\
\n"));
 }

void print_command_COMMAND_PRINT(void){ printf (_("\
   COMMAND_PRINT = Will print out the contents of a Command File.\n\
     -l <Filename> \n\
\n"));
 }

void print_command_RUNSCRIPT_S(void){ printf (_("\
   RUNSCRIPT_S = and alternate inplementation of RUNSCIPT.\n\
     See --help=RUNSCRIPT for more details\n\
     this command Does not use -w or -c thresholds. \n\
	 -l \"<Scriptname> <args>\" \n\
	  Use this command if the RUNSCRIPT fails to give output \n\
	  The Script Timeout does not work with Command.\n\
	  The Command timeout will work. \n\
\n"));
 }

void print_command_CHANGEPASS(void){ printf (_("\
   CHANGEPASS = This command is used to change the Password. \n\
     -l <new password> \n\
      This changes both the default and running Password \n\
\n"));
 }

void print_command_ECHO(void){ printf (_("\
   ECHO = This command is used for NC_NEt to echo the input \n\
     -l <string>\n\
	  String is the text to echo to the output stream\n\
\n"));
 }

void print_command_RUN_CMD_FILE(void){ printf (_("\
   RUN_CMD_FILE = this command is used to run a command file \n\
     -l <Command File> \n\
      a command file consists of a list of commands for NC_Net to run\n\
	  commands are in the format of the test console.\n\
	  The output of the commands is concatinated.\n\
	  after all the commands are run the output is returned \n\
\n"));
 }

void print_command_RUNSCRIP_RAW_S(void){ printf (_("\
   RUNSCRIPT_RAW_S = Same as RUNSCIPT_S but always returns OK.\n\
     See --help=RUNSCRIPT for more details\n\
     this command Does not use -w or -c thresholds. \n\
	 -l \"<Scriptname> <args>\" \n\
\n"));
 }

void print_command_EVENTLOG_NEW(void){ printf (_("\
   EVENTLOG_NEW = Used to querry the Windows event log for events that match the filters.\n\
     THis is the Prefered and Optimized Event Log check. (better performance than EVENTLOG) \n\
	 This check accepts -w and -c\n\
     -l <Event Log List>^<Event Type List>^<Interval> \n\
       ^<Event Source List>^<Event ID List>^<REgular Expresion list> \n\
\n\
     to NOT use a filer you can leave it blank (with no space - NULL) for example  -l \"^^^^^\"\n\
     <Event Log List> is a comma seperated list of Event Log names.  If null all Logs will be used.\n\
     <Event Type List> is a comma seperated list of Event Types. null will match all types.\n\
       only the following are acceptable types: Error,Warning,Information,FailureAudit,SuccessAudit\n\
     <Interval> This value is how old an event Entry can be in min. \n\
	   for example \"^^60^^^\" matches all events in the last hour.\n\
	   if 0 or null the entire event log will be searched.\n\
     <Event Source List> This is a comma seperated list of Source names. \n\
	   (it is not case sensitive.) If null or \"any\" all events will match.\n\
     <Event ID List> This is a comma seperated list of eventID; \n\
	   or a range of Event ID. \n\
	   the range is seperated by a hyphen and the first number must be smaller than the second.\n\
	   example \n\
       1004,6000-9000 will match any event with the ID of 1004 or in the range of 6000 to 9000 inclusive.\n\
     <Regular Expresion List> This is a comma seperated list of regular expresions.\n\
	   Since this is the last token in the input the ^ is acceptable character to use.\n\
	   However the '&' and ',' are not and some other illformed expresions may also fail.\n\
\n"));
 }

void print_command_GETALLCHECK_2(void){ printf (_("\
   GETCHECK = This command will retrive service check results stored in NC_Net.\n\
     Configured Passive checks in NC_Net are automatically stored.\n\
     -l <service description>,<service description>,...\n\
      the -l is a comma delimited list of service descriptions.\n\
      The results are similare to GETALLCHECKS.\n\
\n"));
 }

void print_command_WMICAT_NEW(void){ printf (_("\
   WMICAT_NEW = this command is used to get the formatted WMI output.\n\
   -l <Line Label>,<WMI Class>[,<Attribute Label>,<WMI Attribute>,...]\n\
     Syntex for function is a comma seperated list of  pairs \n\
	 (Labels for Attribute Names , WMI attribute name). \n\
	 The command starts with the (Label for class, WMI Class name). \n\
	 all Classes are assumed to be in the cimv2.\n\
     example command: \n\
     -l \"Hostinfo,win32_operatingsystem,hostname,CSName,time,LocalDateTime\"\n\
     example output:\n\
     Hostinfo: hostname=\"MONTITECH_SRV\" time=\"20070320161638.453000-240\"\n\
\n"));
 }

void print_command_RUNSCRIP_RAW_A(void){ printf (_("\
   RUNSCRIPT__RAW_A = Same as RUNSCIPT but always returns OK.\n\
     See --help=RUNSCRIPT for more details\n\
     this command Does not use -w or -c thresholds. \n\
     -l \"<Scriptname> <args>\" \n\
\n"));
 }

void print_command_OTHER(void){ printf (_("\
   OTHER = this is a catch all command.\n\
     -l <String> \n\
     This command sends the string directly to NC_Net.\n\
	 Syntex of the string should be Identical to using the test console.\n\
\n"));
 }


void print_command( char * optarg) {
	/* this function calls specific help topics based on -h <arg> */
	if(strlen(optarg)<4)
        return;
	if(!strcmp(optarg,"CLIENTVERSION"))
        print_command_CLIENTVERSION();
	else if(!strcmp(optarg,"CPULOAD"))
		print_command_CPULOAD();
	else if(!strcmp(optarg,"UPTIME"))
		print_command_UPTIME();
	else if(!strcmp(optarg,"USEDDISKSPACE"))
		print_command_USEDDISKSPACE();
	else if(!strcmp(optarg,"SERVICESTATE"))
		print_command_SERVICESTATE();
	else if(!strcmp(optarg,"PROCSTATE"))
		print_command_PROCSTATE();
	else if(!strcmp(optarg,"MEMUSE"))
		print_command_MEMUSE();
	else if(!strcmp(optarg,"COUNTER"))
		print_command_COUNTER();
	else if(!strcmp(optarg,"FILEAGE"))
		print_command_FILEAGE();
	else if(!strcmp(optarg,"INSTANCES"))
		print_command_INSTANCES();
	else if(!strcmp(optarg,"EVENTLOG"))
		print_command_EVENTLOG();
	else if(!strcmp(optarg,"WMICHECK"))
		print_command_WMICHECK();
	else if(!strcmp(optarg,"FREEDISKSPACE"))
		print_command_FREEDISKSPACE();
	else if(!strcmp(optarg,"CONFIG"))
		print_command_CONFIG();
	else if(!strcmp(optarg,"ENUMCONFIG"))  
		print_command_ENUMCONFIG();
	else if(!strcmp(optarg,"ENUMPASSIVE"))  
		print_command_ENUMPASSIVE();
	else if(!strcmp(optarg,"DELPASSIVE"))  
		print_command_DELPASSIVE();
	else if(!strcmp(optarg,"ENUMPROCESS"))  
		print_command_ENUMPROCESS();
	else if(!strcmp(optarg,"ENUMSERVICE"))  
		print_command_ENUMSERVICE();
	else if(!strcmp(optarg,"WMICOUNTER"))  
		print_command_WMICOUNTER();
	else if(!strcmp(optarg,"ENUMCOUNTER"))  
		print_command_ENUMCOUNTER();
	else if(!strcmp(optarg,"ADDPASSIVE"))  
		print_command_ADDPASSIVE();
	else if(!strcmp(optarg,"ENUMCOUNTERDESC"))  
		print_command_ENUMCOUNTERDESC();
	else if(!strcmp(optarg,"WMICAT"))  
		print_command_WMICAT();
	else if(!strcmp(optarg,"RUNSCRIPT"))  
		print_command_RUNSCRIPT();
	else if(!strcmp(optarg,"ENUMSCRIPT"))  
		print_command_ENUMSCRIPT();
	else if(!strcmp(optarg,"COPYSCRIPT"))  
		print_command_COPYSCRIPT();
	else if(!strcmp(optarg,"DELSCRIPT"))  
		print_command_DELSCRIPT();
	else if(!strcmp(optarg,"ADDSCRIPT"))  
		print_command_ADDSCRIPT();
	else if(!strcmp(optarg,"CLIENTTIME"))  
		print_command_CLIENTTIME();
	else if(!strcmp(optarg,"GETALLCHECKS"))  
		print_command_GETALLCHECKS();
	else if(!strcmp(optarg,"GECHECK"))  
		print_command_GETCHECK();
	else if(!strcmp(optarg,"ENUMCHECK"))  
		print_command_ENUMCHECK();
	else if(!strcmp(optarg,"DELCHECK"))  
		print_command_DELCHECK();
	else if(!strcmp(optarg,"GETCHECKTIME"))  
		print_command_GETCHECKTIME();
	else if(!strcmp(optarg,"CONFIG_BLIND"))  
		print_command_CONFIG_BLIND();
	else if(!strcmp(optarg,"COMMAND_ENUM"))  
		print_command_COMMAND_ENUM();
	else if(!strcmp(optarg,"COMMAND_COPY"))  
		print_command_COMMAND_COPY();
	else if(!strcmp(optarg,"COMMAND_DEL"))  
		print_command_COMMAND_DEL();
	else if(!strcmp(optarg,"COMMAND_PRINT"))  
		print_command_COMMAND_PRINT();
	else if(!strcmp(optarg,"RUNSCRIPT_S"))  
		print_command_RUNSCRIPT_S();
	else if(!strcmp(optarg,"CHANGEPASS"))  
		print_command_CHANGEPASS();
	else if(!strcmp(optarg,"ECHO"))  
		print_command_ECHO();
	else if(!strcmp(optarg,"RUN_CMD_FILE"))  
		print_command_RUN_CMD_FILE();
	else if(!strcmp(optarg,"RUNSCRIP_RAW_S"))  
		print_command_RUNSCRIP_RAW_S();
	else if(!strcmp(optarg,"EVENTLOG_NEW"))  
		print_command_EVENTLOG_NEW();
	else if(!strcmp(optarg,"GETALLCHECK_2"))  
		print_command_GETALLCHECK_2();
	else if(!strcmp(optarg,"WMICAT_NEW"))  
		print_command_WMICAT_NEW();
	else if(!strcmp(optarg,"RUNSCRIP_RAW_A"))  
		print_command_RUNSCRIP_RAW_A();
	else if(!strcmp(optarg,"OTHER"))  
		print_command_OTHER();
	else
		return;
}

static int my_connect2 (const char *host_name, int port, int *sd, int proto)
{
	struct addrinfo hints;
	struct addrinfo *res, *res0;
	char port_str[6];
	int result;

	memset (&hints, 0, sizeof (hints));
	hints.ai_family = address_family;
	hints.ai_protocol = proto;
	hints.ai_socktype = (proto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM;

	snprintf (port_str, sizeof (port_str), "%d", port);
	result = getaddrinfo (host_name, port_str, &hints, &res0);

	if (result != 0) {
		printf ("%s\n", gai_strerror (result));
		return STATE_UNKNOWN;
	}
	else {
		res = res0;
		while (res) {
			/* attempt to create a socket */
			*sd = socket (res->ai_family, (proto == IPPROTO_UDP) ?
			              SOCK_DGRAM : SOCK_STREAM, res->ai_protocol);

			if (*sd < 0) {
				printf (_("Socket creation failed\n"));
				freeaddrinfo (res);
				return STATE_UNKNOWN;
			}

			/* attempt to open a connection */
			result = connect (*sd, res->ai_addr, res->ai_addrlen);

			if (result == 0) {
				was_refused = FALSE;
				break;
			}

			if (result < 0) {
				switch (errno) {
				case ECONNREFUSED:
					was_refused = TRUE;
					break;
				}
			}

			close (*sd);
			res = res->ai_next;
		}
		freeaddrinfo (res0);
	}

	if (result == 0)
		return STATE_OK;
	else if (was_refused) {
		switch (econn_refuse_state) { /* a user-defined expected outcome */
		case STATE_OK:       
		case STATE_WARNING:  /* user wants WARN or OK on refusal */
			return econn_refuse_state;
			break;
		case STATE_CRITICAL: /* user did not set econn_refuse_state */
			printf ("%s\n", strerror(errno));
			return econn_refuse_state;
			break;
		default: /* it's a logic error if we do not end up in STATE_(OK|WARNING|CRITICAL) */
			return STATE_UNKNOWN;
			break;
		}
	}
	else {
		printf ("%s\n", strerror(errno));
		return STATE_CRITICAL;
	}
}

int process_tcp_request3 (const char *server_address, int server_port,
        const char *send_buffer, char *recv_buffer, int recv_size)
{

        int result;
        int send_result;
        int recv_result;
        int sd;
        struct timeval tv;
        fd_set readfds;
        int recv_length = 0;
	 result = my_connect2 (server_address, server_port, &sd, IPPROTO_TCP);
        if (result != STATE_OK)
                return STATE_CRITICAL;

        send_result = send (sd, send_buffer, strlen (send_buffer), 0);
        if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) {
                printf ("%s\n", _("Send failed"));
                result = STATE_WARNING;
        }

        while (1) {
                /* wait up to the number of seconds for socket timeout
                   minus one for data from the host */
                tv.tv_sec = socket_timeout - 1;
                tv.tv_usec = 0;
                FD_ZERO (&readfds);
                FD_SET (sd, &readfds);
                select (sd + 1, &readfds, NULL, NULL, &tv);

                /* make sure some data has arrived */
                if (!FD_ISSET (sd, &readfds)) { /* it hasn't */
                        if (!recv_length) {
                                strcpy (recv_buffer, "");
                                printf ("%s\n", _("No data was received from host!"));
                                result = STATE_WARNING;
                        }

                        else {         /* this one failed, but previous ones worked */
                                recv_buffer[recv_length] = 0;
                        }
                        break;
                }
                else {         /* it has */
                        recv_result =
                                recv (sd, recv_buffer + recv_length ,
                                        (size_t)recv_size - recv_length  - 1, 0);
                        if (recv_result == -1) {
                                /* recv failed, bail out */
                                strcpy (recv_buffer + recv_length, "");
                                result = STATE_WARNING;
                                break;
                        }
                        else if (recv_result == 0) {
                                /* end of file ? */
                                recv_buffer[recv_length] = 0;
                                break;
                        }
                        else {  /* we got data */
				recv_length += recv_result;
				if (recv_length >= recv_size - 1) {
					/* buffer full, but not done */
                                        recv_buffer[recv_size - 1] = 0;
                                        /* ready to print */
					/* modified to stream to output stream */
					printf( "%s", recv_buffer );
					strcpy (recv_buffer, "");
					recv_length = 0;
				}
                        }
                }
                /* end if(!FD_ISSET(sd,&readfds)) */
        }
        /* end while(1) */

        close (sd);
        return result;
}