Added state retention APIs. Implemented for check_snmp with --rate option.

See http://nagiosplugin.org/c-api-private for more details on the API.

Also updated check_snmp -l option to change the perfdata label.

10 files changed, 593 insertions, 2 deletions

diff --git a/lib/Makefile.am b/lib/Makefile.am
index 17e4c1b0..99fa591a 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -4,6 +4,7 @@ SUBDIRS = . tests
 
 noinst_LIBRARIES = libnagiosplug.a
 
+AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\"
 
 libnagiosplug_a_SOURCES = utils_base.c utils_disk.c utils_tcp.c utils_cmd.c
 EXTRA_DIST = utils_base.h utils_disk.h utils_tcp.h utils_cmd.h parse_ini.h extra_opts.h
diff --git a/lib/tests/Makefile.am b/lib/tests/Makefile.am
index 694baf00..06a4b423 100644
--- a/lib/tests/Makefile.am
+++ b/lib/tests/Makefile.am
@@ -5,6 +5,8 @@ noinst_PROGRAMS = @EXTRA_TEST@
 TESTS = @EXTRA_TEST@
 check_PROGRAMS = @EXTRA_TEST@
 
+AM_CPPFLAGS = -DNP_STATE_DIR_PREFIX=\"$(localstatedir)\"
+
 INCLUDES = -I$(top_srcdir)/lib -I$(top_srcdir)/gl -I$(top_srcdir)/intl -I$(top_srcdir)/plugins
 
 EXTRA_PROGRAMS = test_utils test_disk test_tcp test_cmd test_base64 test_ini1 test_ini3 test_opts1 test_opts2 test_opts3
diff --git a/lib/tests/test_utils.c b/lib/tests/test_utils.c
index 3a45944a..53369077 100644
--- a/lib/tests/test_utils.c
+++ b/lib/tests/test_utils.c
@@ -21,6 +21,11 @@
 
 #include "tap.h"
 
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "utils_base.c"
+
 int
 main (int argc, char **argv)
 {
@@ -28,8 +33,31 @@ main (int argc, char **argv)
 	double	temp;
 	thresholds *thresholds = NULL;
 	int	rc;
+	char	*temp_string;
+	state_key *temp_state_key = NULL;
+	state_data *temp_state_data;
+	time_t	current_time;
+	char 	*temp_filename;
+	FILE    *temp_fp;
+
+	plan_tests(141);
+
+	ok( this_nagios_plugin==NULL, "nagios_plugin not initialised");
+
+	np_init( "check_test", argc, argv );
+
+	ok( this_nagios_plugin!=NULL, "nagios_plugin now initialised");
+	ok( !strcmp(this_nagios_plugin->plugin_name, "check_test"), "plugin name initialised" );
+
+	ok( this_nagios_plugin->argc==argc, "Argc set" );
+	ok( this_nagios_plugin->argv==argv, "Argv set" );
 
-	plan_tests(81+23);
+	np_set_args(0,0);
+
+	ok( this_nagios_plugin->argc==0, "argc changed" );
+	ok( this_nagios_plugin->argv==0, "argv changed" );
+
+	np_set_args(argc, argv);
 
 	range = parse_range_string("6");
 	ok( range != NULL, "'6' is valid range");
@@ -251,5 +279,157 @@ main (int argc, char **argv)
 	test=np_extract_ntpvar("", "foo");
 	ok(!test, "Empty string return NULL");
 
+
+	/* This is the result of running ./test_utils */
+	temp_string = (char *) _np_state_generate_key();
+	ok(!strcmp(temp_string, "83d877b6cdfefb5d6f06101fd6fe76762f21792c"), "Got hash with exe and no parameters" ) || 
+        diag( "You are probably running in wrong directory. Must run as ./test_utils" );
+
+
+	this_nagios_plugin->argc=4;
+	this_nagios_plugin->argv[0] = "./test_utils";
+	this_nagios_plugin->argv[1] = "here";
+	this_nagios_plugin->argv[2] = "--and";
+	this_nagios_plugin->argv[3] = "now";
+	temp_string = (char *) _np_state_generate_key();
+	ok(!strcmp(temp_string, "94b5e17bf5abf51cb15aff5f69b96f2f8dac5ecd"), "Got based on expected argv" );
+
+	unsetenv("NAGIOS_PLUGIN_STATE_DIRECTORY");
+	temp_string = (char *) _np_state_calculate_location_prefix();
+	ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory" );
+
+	setenv("NAGIOS_PLUGIN_STATE_DIRECTORY", "", 1);
+	temp_string = (char *) _np_state_calculate_location_prefix();
+	ok(!strcmp(temp_string, NP_STATE_DIR_PREFIX), "Got default directory even with empty string" );
+
+	setenv("NAGIOS_PLUGIN_STATE_DIRECTORY", "/usr/local/nagios/var", 1);
+	temp_string = (char *) _np_state_calculate_location_prefix();
+	ok(!strcmp(temp_string, "/usr/local/nagios/var"), "Got default directory" );
+
+
+
+	ok(temp_state_key==NULL, "temp_state_key initially empty");
+
+	this_nagios_plugin->argc=1;
+	this_nagios_plugin->argv[0] = "./test_utils";
+	np_enable_state(NULL, 51);
+	temp_state_key = this_nagios_plugin->state;
+	ok( !strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name" );
+	ok( !strcmp(temp_state_key->name, "83d877b6cdfefb5d6f06101fd6fe76762f21792c"), "Got generated filename" );
+
+
+	np_enable_state("allowedchars_in_keyname", 77);
+	temp_state_key = this_nagios_plugin->state;
+	ok( !strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name" );
+	ok( !strcmp(temp_state_key->name, "allowedchars_in_keyname"), "Got key name with valid chars" );
+	ok( !strcmp(temp_state_key->_filename, "/usr/local/nagios/var/check_test/allowedchars_in_keyname"), "Got internal filename" );
+
+
+	/* Don't do this test just yet. Will die */
+	/*
+	np_enable_state("bad^chars$in@here", 77);
+	temp_state_key = this_nagios_plugin->state;
+	ok( !strcmp(temp_state_key->name, "bad_chars_in_here"), "Got key name with bad chars replaced" );
+	*/
+
+	np_enable_state("funnykeyname", 54);
+	temp_state_key = this_nagios_plugin->state;
+	ok( !strcmp(temp_state_key->plugin_name, "check_test"), "Got plugin name" );
+	ok( !strcmp(temp_state_key->name, "funnykeyname"), "Got key name" );
+
+
+
+	ok( !strcmp(temp_state_key->_filename, "/usr/local/nagios/var/check_test/funnykeyname"), "Got internal filename" );
+	ok( temp_state_key->data_version==54, "Version set" );
+
+	temp_state_data = np_state_read(temp_state_key);
+	ok( temp_state_data==NULL, "Got no state data as file does not exist" );
+
+
+/*
+	temp_fp = fopen("var/statefile", "r");
+	if (temp_fp==NULL) 
+		printf("Error opening. errno=%d\n", errno);
+	printf("temp_fp=%s\n", temp_fp);
+	ok( _np_state_read_file(temp_fp) == TRUE, "Can read state file" );
+	fclose(temp_fp);
+*/
+	
+	temp_state_key->_filename="var/statefile";
+	temp_state_data = np_state_read(temp_state_key);
+	ok( this_nagios_plugin->state->state_data!=NULL, "Got state data now" ) || diag("Are you running in right directory? Will get coredump next if not");
+	ok( this_nagios_plugin->state->state_data->time==1234567890, "Got time" );
+	ok( !strcmp((char *)this_nagios_plugin->state->state_data->data, "String to read"), "Data as expected" );
+
+	temp_state_key->data_version=53;
+	temp_state_data = np_state_read(temp_state_key);
+	ok( temp_state_data==NULL, "Older data version gives NULL" );
+	temp_state_key->data_version=54;
+
+	temp_state_key->_filename="var/nonexistant";
+	temp_state_data = np_state_read(temp_state_key);
+	ok( temp_state_data==NULL, "Missing file gives NULL" );
+	ok( this_nagios_plugin->state->state_data==NULL, "No state information" );
+
+	temp_state_key->_filename="var/oldformat";
+	temp_state_data = np_state_read(temp_state_key);
+	ok( temp_state_data==NULL, "Old file format gives NULL" );
+
+	temp_state_key->_filename="var/baddate";
+	temp_state_data = np_state_read(temp_state_key);
+	ok( temp_state_data==NULL, "Bad date gives NULL" );
+
+	temp_state_key->_filename="var/missingdataline";
+	temp_state_data = np_state_read(temp_state_key);
+	ok( temp_state_data==NULL, "Missing data line gives NULL" );
+
+
+
+
+	unlink("var/generated");
+	temp_state_key->_filename="var/generated";
+	current_time=1234567890;
+	np_state_write_string(current_time, "String to read");
+	ok(system("cmp var/generated var/statefile")==0, "Generated file same as expected");
+
+
+
+
+	unlink("var/generated_directory/statefile");
+	unlink("var/generated_directory");
+	temp_state_key->_filename="var/generated_directory/statefile";
+	current_time=1234567890;
+	np_state_write_string(current_time, "String to read");
+	ok(system("cmp var/generated_directory/statefile var/statefile")==0, "Have created directory");
+
+	/* This test to check cannot write to dir - can't automate yet */
+	/*
+	unlink("var/generated_bad_dir");
+	mkdir("var/generated_bad_dir", S_IRUSR);
+	np_state_write_string(current_time, "String to read");
+	*/
+
+
+	temp_state_key->_filename="var/generated";
+	time(&current_time);
+	np_state_write_string(0, "String to read");
+	temp_state_data = np_state_read(temp_state_key);
+	/* Check time is set to current_time */
+	ok(system("cmp var/generated var/statefile > /dev/null")!=0, "Generated file should be different this time");
+	ok(this_nagios_plugin->state->state_data->time-current_time<=1, "Has time generated from current time");
+	
+
+	/* Don't know how to automatically test this. Need to be able to redefine die and catch the error */
+	/*
+	temp_state_key->_filename="/dev/do/not/expect/to/be/able/to/write";
+	np_state_write_string(0, "Bad file");
+	*/
+	
+
+	np_cleanup();
+
+	ok( this_nagios_plugin==NULL, "Free'd this_nagios_plugin" );
+
 	return exit_status();
 }
+
diff --git a/lib/tests/var/.gitignore b/lib/tests/var/.gitignore
new file mode 100644
index 00000000..95a59c17
--- /dev/null
+++ b/lib/tests/var/.gitignore
@@ -0,0 +1,2 @@
+generated
+generated_directory/
diff --git a/lib/tests/var/baddate b/lib/tests/var/baddate
new file mode 100644
index 00000000..2fda432e
--- /dev/null
+++ b/lib/tests/var/baddate
@@ -0,0 +1,5 @@
+# NP State file
+1
+54
+2147483647
+Date in future!!!!
diff --git a/lib/tests/var/missingdataline b/lib/tests/var/missingdataline
new file mode 100644
index 00000000..d87f73aa
--- /dev/null
+++ b/lib/tests/var/missingdataline
@@ -0,0 +1,4 @@
+# NP State file
+1
+54
+1234567890
diff --git a/lib/tests/var/oldformat b/lib/tests/var/oldformat
new file mode 100644
index 00000000..102f8c9f
--- /dev/null
+++ b/lib/tests/var/oldformat
@@ -0,0 +1,5 @@
+# NP State file
+0
+54
+1234567890
+String to read
diff --git a/lib/tests/var/statefile b/lib/tests/var/statefile
new file mode 100644
index 00000000..5002139c
--- /dev/null
+++ b/lib/tests/var/statefile
@@ -0,0 +1,5 @@
+# NP State file
+1
+54
+1234567890
+String to read
diff --git a/lib/utils_base.c b/lib/utils_base.c
index 4303e159..6de92cbd 100644
--- a/lib/utils_base.c
+++ b/lib/utils_base.c
@@ -27,6 +27,56 @@
 #include "common.h"
 #include <stdarg.h>
 #include "utils_base.h"
+#include <fcntl.h>
+
+#define np_free(ptr) { if(ptr) { free(ptr); ptr = NULL; } }
+
+nagios_plugin *this_nagios_plugin=NULL;
+
+void np_init( char *plugin_name, int argc, char **argv ) {
+	if (this_nagios_plugin==NULL) {
+		this_nagios_plugin = malloc(sizeof(nagios_plugin));
+		if (this_nagios_plugin==NULL) {
+			die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
+			    strerror(errno));
+		}
+		this_nagios_plugin->plugin_name = strdup(plugin_name);
+		if (this_nagios_plugin->plugin_name==NULL)
+			die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
+		this_nagios_plugin->argc = argc;
+		this_nagios_plugin->argv = argv;
+	}
+}
+
+void np_set_args( int argc, char **argv ) {
+	if (this_nagios_plugin==NULL)
+		die(STATE_UNKNOWN, _("This requires np_init to be called"));
+
+	this_nagios_plugin->argc = argc;
+	this_nagios_plugin->argv = argv;
+}
+
+
+void np_cleanup() {
+	if (this_nagios_plugin!=NULL) {
+		if(this_nagios_plugin->state!=NULL) {
+			if(this_nagios_plugin->state->state_data) { 
+				np_free(this_nagios_plugin->state->state_data->data);
+				np_free(this_nagios_plugin->state->state_data);
+			}
+			np_free(this_nagios_plugin->state->name);
+			np_free(this_nagios_plugin->state);
+		}
+		np_free(this_nagios_plugin->plugin_name);
+		np_free(this_nagios_plugin);
+	}
+	this_nagios_plugin=NULL;
+}
+
+/* Hidden function to get a pointer to this_nagios_plugin for testing */
+void _get_nagios_plugin( nagios_plugin **pointer ){
+	*pointer = this_nagios_plugin;
+}
 
 void
 die (int result, const char *fmt, ...)
@@ -35,6 +85,9 @@ die (int result, const char *fmt, ...)
 	va_start (ap, fmt);
 	vprintf (fmt, ap);
 	va_end (ap);
+	if(this_nagios_plugin!=NULL) {
+		np_cleanup();
+	}
 	exit (result);
 }
 
@@ -102,7 +155,7 @@ _set_thresholds(thresholds **my_thresholds, char *warn_string, char *critical_st
 	thresholds *temp_thresholds = NULL;
 
 	if ((temp_thresholds = malloc(sizeof(thresholds))) == NULL)
-		die(STATE_UNKNOWN, _("Cannot allocate memory: %s\n"),
+		die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
 		    strerror(errno));
 
 	temp_thresholds->warning = NULL;
@@ -310,3 +363,302 @@ char *np_extract_value(const char *varlist, const char *name, char sep) {
 	return value;
 }
 
+/*
+ * Returns a string to use as a keyname, based on an md5 hash of argv, thus
+ * hopefully a unique key per service/plugin invocation. Use the extra-opts
+ * parse of argv, so that uniqueness in parameters are reflected there.
+ */
+char *_np_state_generate_key() {
+	struct sha1_ctx ctx;
+	int i;
+	char **argv = this_nagios_plugin->argv;
+	unsigned char result[20];
+	char keyname[41];
+	char *p=NULL;
+
+	sha1_init_ctx(&ctx);
+	
+	for(i=0; i<this_nagios_plugin->argc; i++) {
+		sha1_process_bytes(argv[i], strlen(argv[i]), &ctx);
+	}
+
+	sha1_finish_ctx(&ctx, &result);
+	
+	for (i=0; i<20; ++i) {
+		sprintf(&keyname[2*i], "%02x", result[i]);
+	}
+	keyname[40]='\0';
+	
+	p = strdup(keyname);
+	if(p==NULL) {
+		die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
+	}
+	return p;
+}
+
+void _cleanup_state_data() {
+	if (this_nagios_plugin->state->state_data!=NULL) {
+		np_free(this_nagios_plugin->state->state_data->data);
+		np_free(this_nagios_plugin->state->state_data);
+	}
+}
+
+/*
+ * Internal function. Returns either:
+ *   envvar NAGIOS_PLUGIN_STATE_DIRECTORY
+ *   statically compiled shared state directory
+ */
+char* _np_state_calculate_location_prefix(){
+	char *env_dir;
+
+	env_dir = getenv("NAGIOS_PLUGIN_STATE_DIRECTORY");
+	if(env_dir && env_dir[0] != '\0')
+		return env_dir;
+	return NP_STATE_DIR_PREFIX;
+}
+
+/*
+ * Initiatializer for state routines.
+ * Sets variables. Generates filename. Returns np_state_key. die with
+ * UNKNOWN if exception
+ */
+void np_enable_state(char *keyname, int expected_data_version) {
+	state_key *this_state = NULL;
+	char *temp_filename = NULL;
+	char *temp_keyname = NULL;
+	char *p=NULL;
+
+	if(this_nagios_plugin==NULL)
+		die(STATE_UNKNOWN, _("This requires np_init to be called"));
+
+	this_state = (state_key *) malloc(sizeof(state_key));
+	if(this_state==NULL)
+		die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
+		    strerror(errno));
+
+	if(keyname==NULL) {
+		temp_keyname = _np_state_generate_key();
+	} else {
+		temp_keyname = strdup(keyname);
+		if(temp_keyname==NULL)
+			die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
+	}
+	/* Die if invalid characters used for keyname */
+	p = temp_keyname;
+	while(*p!='\0') {
+		if(! (isalnum(*p) || *p == '_')) {
+			die(STATE_UNKNOWN, _("Invalid character for keyname - only alphanumerics or '_'"));
+		}
+		p++;
+	}
+	this_state->name=temp_keyname;
+	this_state->plugin_name=this_nagios_plugin->plugin_name;
+	this_state->data_version=expected_data_version;
+	this_state->state_data=NULL;
+
+	/* Calculate filename */
+	asprintf(&temp_filename, "%s/%s/%s", _np_state_calculate_location_prefix(), this_nagios_plugin->plugin_name, this_state->name);
+	this_state->_filename=temp_filename;
+
+	this_nagios_plugin->state = this_state;
+}
+
+/*
+ * Will return NULL if no data is available (first run). If key currently
+ * exists, read data. If state file format version is not expected, return
+ * as if no data. Get state data version number and compares to expected.
+ * If numerically lower, then return as no previous state. die with UNKNOWN
+ * if exceptional error.
+ */
+state_data *np_state_read() {
+	state_key *my_state_key;
+	state_data *this_state_data=NULL;
+	FILE *statefile;
+	int c;
+	int rc = FALSE;
+
+	if(this_nagios_plugin==NULL)
+		die(STATE_UNKNOWN, _("This requires np_init to be called"));
+
+	/* Open file. If this fails, no previous state found */
+	statefile = fopen( this_nagios_plugin->state->_filename, "r" );
+	if(statefile!=NULL) {
+
+		this_state_data = (state_data *) malloc(sizeof(state_data));
+		if(this_state_data==NULL)
+			die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
+			    strerror(errno));
+
+		this_state_data->data=NULL;
+		this_nagios_plugin->state->state_data = this_state_data;
+
+		rc = _np_state_read_file(statefile);
+
+		fclose(statefile);
+	}
+
+	if(rc==FALSE) {
+		_cleanup_state_data();
+	}
+
+	return this_nagios_plugin->state->state_data;
+}
+
+/* 
+ * Read the state file
+ */
+int _np_state_read_file(FILE *f) {
+	int c, status=FALSE;
+	size_t pos;
+	char *line;
+	int i;
+	int failure=0;
+	time_t current_time, data_time;
+	enum { STATE_FILE_VERSION, STATE_DATA_VERSION, STATE_DATA_TIME, STATE_DATA_TEXT, STATE_DATA_END } expected=STATE_FILE_VERSION;
+
+	time(&current_time);
+
+	/* Note: This introduces a limit of 1024 bytes in the string data */
+	line = (char *) malloc(1024);
+	if(line==NULL)
+		die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
+		    strerror(errno));
+
+	while(!failure && (fgets(line,1024,f))!=NULL){
+		pos=strlen(line);
+		if(line[pos-1]=='\n') {
+			line[pos-1]='\0';
+		}
+
+		if(line[0] == '#') continue;
+
+		switch(expected) {
+			case STATE_FILE_VERSION:
+				i=atoi(line);
+				if(i!=NP_STATE_FORMAT_VERSION)
+					failure++;
+				else
+					expected=STATE_DATA_VERSION;
+				break;
+			case STATE_DATA_VERSION:
+				i=atoi(line);
+				if(i != this_nagios_plugin->state->data_version)
+					failure++;
+				else
+					expected=STATE_DATA_TIME;
+				break;
+			case STATE_DATA_TIME:
+				/* If time > now, error */
+				data_time=strtoul(line,NULL,10);
+				if(data_time > current_time)
+					failure++;
+				else {
+					this_nagios_plugin->state->state_data->time = data_time;
+					expected=STATE_DATA_TEXT;
+				}
+				break;
+			case STATE_DATA_TEXT:
+				this_nagios_plugin->state->state_data->data = strdup(line);
+				if(this_nagios_plugin->state->state_data->data==NULL)
+					die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
+				expected=STATE_DATA_END;
+				status=TRUE;
+				break;
+			case STATE_DATA_END:
+				;
+		}
+	}
+
+	np_free(line);
+	return status;
+}
+
+/*
+ * If time=NULL, use current time. Create state file, with state format 
+ * version, default text. Writes version, time, and data. Avoid locking 
+ * problems - use mv to write and then swap. Possible loss of state data if 
+ * two things writing to same key at same time. 
+ * Will die with UNKNOWN if errors
+ */
+void np_state_write_string(time_t data_time, char *data_string) {
+	FILE *fp;
+	char *temp_file=NULL;
+	int fd=0, result=0;
+	time_t current_time;
+	size_t len;
+	char *directories=NULL;
+	char *p=NULL;
+
+	if(data_time==0)
+		time(&current_time);
+	else
+		current_time=data_time;
+	
+	/* If file doesn't currently exist, create directories */
+	if(access(this_nagios_plugin->state->_filename,F_OK)!=0) {
+		asprintf(&directories, "%s", this_nagios_plugin->state->_filename);
+		if(directories==NULL)
+			die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
+			    strerror(errno));
+
+		for(p=directories+1; *p; p++) {
+			if(*p=='/') {
+				*p='\0';
+				if((access(directories,F_OK)!=0) && (mkdir(directories, S_IRWXU)!=0)) {
+					/* Can't free this! Otherwise error message is wrong! */
+					/* np_free(directories); */ 
+					die(STATE_UNKNOWN, _("Cannot create directory: %s"), directories);
+				}
+				*p='/';
+			}
+		}
+		np_free(directories);
+	}
+
+	asprintf(&temp_file,"%s.XXXXXX",this_nagios_plugin->state->_filename);
+	if(temp_file==NULL)
+		die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
+		    strerror(errno));
+
+	if((fd=mkstemp(temp_file))==-1) {
+		np_free(temp_file);
+		die(STATE_UNKNOWN, _("Cannot create temporary filename"));
+	}
+
+	fp=(FILE *)fdopen(fd,"w");
+	if(fp==NULL) {
+		close(fd);
+		unlink(temp_file);
+		np_free(temp_file);
+		die(STATE_UNKNOWN, _("Unable to open temporary state file"));
+	}
+	
+	fprintf(fp,"# NP State file\n");
+	fprintf(fp,"%d\n",NP_STATE_FORMAT_VERSION);
+	fprintf(fp,"%d\n",this_nagios_plugin->state->data_version);
+	fprintf(fp,"%lu\n",current_time);
+	fprintf(fp,"%s\n",data_string);
+	
+	fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP);
+	
+	fflush(fp);
+
+	result=fclose(fp);
+
+	fsync(fd);
+
+	if(result!=0) {
+		unlink(temp_file);
+		np_free(temp_file);
+		die(STATE_UNKNOWN, _("Error writing temp file"));
+	}
+
+	if(rename(temp_file, this_nagios_plugin->state->_filename)!=0) {
+		unlink(temp_file);
+		np_free(temp_file);
+		die(STATE_UNKNOWN, _("Cannot rename state temp file"));
+	}
+
+	np_free(temp_file);
+}
+
diff --git a/lib/utils_base.h b/lib/utils_base.h
index 49e40a63..0cb371fd 100644
--- a/lib/utils_base.h
+++ b/lib/utils_base.h
@@ -2,6 +2,8 @@
 #define _UTILS_BASE_
 /* Header file for nagios plugins utils_base.c */
 
+#include "sha1.h"
+
 /* This file holds header information for thresholds - use this in preference to 
    individual plugin logic */
 
@@ -28,6 +30,30 @@ typedef struct thresholds_struct {
 	range	*critical;
 	} thresholds;
 
+#define NP_STATE_FORMAT_VERSION 1
+
+typedef struct state_data_struct {
+	time_t	time;
+	void	*data;
+	int	length; /* Of binary data */
+	} state_data;
+
+
+typedef struct state_key_struct {
+	char       *name;
+	char       *plugin_name;
+	int        data_version;
+	char       *_filename;
+	state_data *state_data;
+	} state_key;
+
+typedef struct np_struct {
+	char      *plugin_name;
+	state_key *state;
+	int       argc;
+	char      **argv;
+	} nagios_plugin;
+
 range *parse_range_string (char *);
 int _set_thresholds(thresholds **, char *, char *);
 void set_thresholds(thresholds **, char *, char *);
@@ -67,4 +93,13 @@ char *np_extract_value(const char*, const char*, char);
  */
 #define np_extract_ntpvar(l, n) np_extract_value(l, n, ',')
 
+
+void np_enable_state(char *, int);
+state_data *np_state_read();
+void np_state_write_string(time_t, char *);
+
+void np_init(char *, int argc, char **argv);
+void np_set_args(int argc, char **argv);
+void np_cleanup();
+
 #endif /* _UTILS_BASE_ */