#include "settings.h"
extern int errno;

#include <time.h>

/* private interface methods start*/
static gboolean copy_file(const gchar* source, const gchar* destination) ;
static gboolean jail_new_from_file(const gchar* dir, gchar* canonical_name, struct jail** out) ;
static gboolean jail_is_assigned(GKeyFile* settings, int uid);
static int settings_get_free_jail(GKeyFile* settings);

static gboolean settings_set_jail_uid(GKeyFile* settings, const gchar* jail_name, int uid);
/* private interface methods end */

// convert from host:ip:port to ip:port
static gchar* get_host(gchar* group_host) {
	return group_host+strlen("host:");
}

// convert from enum to char
enum hostaction char2enum(gchar* action) {
	if (strcasecmp(action, "deny") == 0)
		return DENY;
	else if(strcasecmp(action, "allow") == 0)
		return ALLOW;
	else if(strcasecmp(action, "ask") == 0)
		return ASK;
	else if(strcasecmp(action, "allowentry") == 0)
		return ALLOWENTRY;
	else 
		return ERROR;
}

// convert from char to enum
 gchar* enum2char(enum hostaction action) {
	if (action == DENY)
		return "deny";
	else if(action == ALLOW)
		return "allow";
	else if(action == ASK)
		return "ask";
	else if(action == ALLOWENTRY)
		return "allowentry";
	else
		return "error";
}


/* taken from gnucash and slightly modified */
GKeyFile *
settings_load_from_file (const gchar * filename, gboolean ignore_error,  gboolean return_empty_struct)
{
	GKeyFile *key_file;
	GError *error = NULL;

	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "settings_load_from_file ENTER\n");
	
	if (!filename)
		return FALSE;

	if (!g_file_test (filename, G_FILE_TEST_EXISTS))
		return NULL;

	key_file = g_key_file_new ();
	if (!key_file)
		return NULL;

	if (g_key_file_load_from_file(key_file, filename, G_KEY_FILE_KEEP_COMMENTS, &error)) {
		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "settings_load_from_file LEAVE SUCCESS\n");
		return key_file;
	}

	/* An error occurred */
	if (!return_empty_struct) {
		g_key_file_free (key_file);
		key_file = NULL;
	}

	if (!ignore_error)
		g_warning ("Unable to read file %s: %s\n", filename, error->message);

	g_error_free (error);
	
	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "settings_load_from_file LEAVE FAILURE\n");
	
	return key_file;
}


/* taken from gnucash and slightly modified */
gboolean settings_save_to_file (const gchar * filename, GKeyFile * key_file,
					   GError ** error)
{
	gchar *contents;
	gint fd;
	gint length;
	ssize_t written;
	gboolean success = TRUE;

	if (filename == NULL || key_file == NULL)
		return FALSE;

	contents = g_key_file_to_data (key_file, NULL, NULL);
	length = strlen (contents);
	fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
	if (fd == -1) {
		if (error) {
			*error = g_error_new (G_FILE_ERROR, g_file_error_from_errno (errno),
							 "Cannot open file %s: %s", filename,
							 strerror (errno));
		}
		else {
			g_critical ("Cannot open file %s: %s\n", filename,
						strerror (errno));
		}
		g_free (contents);
		return FALSE;
	}

	written = write (fd, contents, length);
	if (written == -1) {
		success = FALSE;
		if (error) {
			*error = g_error_new (G_FILE_ERROR, g_file_error_from_errno (errno),
							 "Cannot write to file %s: %s", filename,
							 strerror (errno));
		}
		else {
			g_critical ("Cannot write to file %s: %s\n", filename,
						strerror (errno));
		}
		close (fd);
	}
	else if (written != length) {
		success = FALSE;
		if (error) {
			*error = g_error_new (G_FILE_ERROR, g_file_error_from_errno (errno),
							 "File %s truncated (provided %d, written %d)",
							 filename, length, (int) written);
		}
		else {
			g_critical ("File %s truncated (provided %d, written %d)",
						filename, length, (int) written);
		}
		/* Ignore any error */
		close (fd);
	}
	else if (close (fd) == -1) {
		if (error) {
			*error = g_error_new (G_FILE_ERROR, g_file_error_from_errno (errno),
							 "Close failed for file %s: %s", filename,
							 strerror (errno));
		}
		else {
			g_warning ("Close failed for file %s: %s", filename,
					   strerror (errno));
		}
	}
	g_free (contents);
	return success;
}

 

// print the host structure in human readable form
void host_print(struct host* h) {
	g_assert(h != NULL);
	
	gchar** execve = h->execve;
	g_print("host_addr:\t%s\n", h->host_addr);
	g_print("action:\t%s\n", enum2char(h->action));
	g_print("cmd:\t%s\n", h->cmd);
	g_print("execve:{");
	
	while (execve && *execve) {
		g_print("%s ",*execve);
		execve++;
	}			
	g_print("}\n");
	g_print("keys:{");
	
	FOREACH_LIST(h->keys, key) {
		g_print("%s ", (char*)key->data);
	}
	
	g_print("}\n");
	
}

struct host* host_dup(struct host* old) {
	struct host* ret = malloc(sizeof (struct host));

	if (ret == NULL) 
		g_error("no memory left\n");
	
	memset(ret, 0, sizeof(struct host));
	
	// make the new rule COPY OVER
	ret->action = old->action;
	SAFE_STRNCPY(ret->host_addr, old->host_addr, MAX_HOST);	
	SAFE_STRNCPY(ret->cmd, old->cmd, MAX_PATH);	
	
	if (ret->execve)
		ret->execve = g_strdupv(old->execve);
		
	FOREACH_LIST(ret->keys, key) {
		ret->keys = g_list_append(ret->keys, key->data);
	}

			
	return ret;
	
}

// load policies
void policy_new(int main_uid, struct policies* out) {
	DIR* proc;
	struct dirent* dirp;
	struct jail* new_jail;
	char default_path[MAX_PATH+1];
	int uid = -1;
	GError *err = NULL;

	out->uid2jailstruct = g_hash_table_new(NULL, NULL);

	proc = opendir(out->policy_path);

	if (proc == NULL)
		g_error("load_policy:could not open policy dir %s:%s\n", out->policy_path, g_strerror(errno));
	

	if (!SAFE_SNPRINTF(default_path, MAX_PATH, "%s/%s", out->policy_path, "default")) {
		g_error("policy_new:failure to concatenate paths\n");
	} 
	
	if (access(default_path, R_OK)) {
		g_error("policy_new:could not find the default policy in %s\n", default_path);
	}
	
	// try to load the main policy
//	if (jail_new_from_file(out->policy_path, "main",  &new_jail)==FALSE)
//		g_error("load_policy:could not main policy dir:%s\n", g_strerror(errno));
	
//	out->main = new_jail;
//	g_hash_table_insert(out->uid2jailstruct, GINT_TO_POINTER(main_uid), new_jail);
	
	while ( (dirp = readdir(proc)) ) {
		// load the policy but ignore main and default policies
		if (strcmp(dirp->d_name, "..")==0 || strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "default") == 0)
			continue;			
	
		if (jail_new_from_file(out->policy_path, dirp->d_name,  &new_jail)) {
			g_print("loaded jail with canonical namd %s\n", dirp->d_name);
			
			// find which uid this jail is associated with
			uid = settings_get_jail_uid(out->settings, dirp->d_name);
			if (uid == -1) {
				uid = settings_get_free_jail(out->settings);
				if (uid == -1) {
					g_print("policy_new:there are no free slots for this new jail\n");
					continue;					
				}
				g_print("no associate for jail %s will associate with uid %d\n", new_jail->name, uid);
				
				settings_set_jail_uid(out->settings, new_jail->name, uid);
				
				// update the settings file
				settings_save_to_file(out->settings_file, out->settings, &err);						
				if (err)
					g_error("policy_new: failed to update settings file\n");			
			}
			
			g_hash_table_insert(out->uid2jailstruct, GINT_TO_POINTER(uid), new_jail);

		}		
	}

	if (proc)
		closedir(proc);

	return;
}


// NOT FINISHED AT ALL
void policy_free(struct policies* in) {
	if (in) {
		free(in);
	}

	// clear up the hash table and all the jails
}

// match the host wildcard with a given uid. if we find it, we return the pointer to the host structure
// that describes the policy for that host
gboolean jail_match_policy(const gchar* hostregex, struct jail* jail_in, struct host** host_out) {
	pcre* re = NULL;
	const char *error = NULL;
	gint erroffset;
	int rc;
	int ovector[30];
	struct host* host;
	
	g_assert(jail_in != NULL);
	g_assert(hostregex != NULL);		

	// iterate over all sequentially, and try to match the host via regex
	FOREACH_LIST(jail_in->hosts, host_key) {
		host = (struct host*)host_key->data;
			
		// compile regex 
		re = pcre_compile(host->host_addr, 0, &error, &erroffset, NULL);
		if (re == NULL) { 
			g_warning("jail_match_policy:%s\n", error?error:"");		
			return FALSE;
		}
		
		rc = pcre_exec(re, NULL, hostregex, strlen(hostregex), 0, 0, ovector, 30);
		if (rc >= 0) {
			pcre_free(re);
			*host_out = host;
			return TRUE;
		} else if (re)
			pcre_free(re);
	}	
		
	return FALSE;
}

// free the host
void host_free(struct host* h) {
	g_assert(h != NULL);
	if (h->execve) 
		g_strfreev(h->execve);	
		
	while (h->keys) {
		if (h->keys->data) {
			free(h->keys->data);			
		}
		h->keys = h->keys->next;
	}
	
	free(h);
}

// clean up the linked list of host structures
void jail_free(struct jail* in){		
	g_assert(in != NULL);
	
	while (in->hosts) {
		if (in->hosts->data) {
			host_free((struct host*)in->hosts->data);
		}
		in->hosts = in->hosts->next;		
	}
	free(in);
} 

struct policy_search_result {struct jail* jail_result; struct host* host_result; gchar* host_addr;} srch;
	
// callback for g_hash_table_foreach. pretty ugly
void has_primary_host(gpointer key, gpointer value, gpointer user_data) {
	struct jail* haystack = (struct jail*)value;	// current jail that we are lokoing at
	struct host* host_result;							// resultant which will point to the host structure found
	
	// we already found it
	if (srch.jail_result != NULL)							// this will be called many times
		return;										// if search->ret is already filled in, somebody found it before us
												
	if (jail_match_policy(srch.host_addr, haystack, &host_result)) {
		srch.jail_result = (host_result->action==ALLOWENTRY)?(haystack):(NULL);	// this will pass the result back to the caller
		srch.host_result = host_result;
		
		return;
	}		
}

// given a certain policy, find in which jail resides the primary host addr host_addr
// and return the pointer to it
gboolean policy_search_entry_point(	struct policies* policy,	gchar* host_regex,
									struct jail** jail_result,	struct host** host_result) {	
	
	srch.jail_result = NULL;
	srch.host_result = NULL;
	srch.host_addr = host_regex;
	g_hash_table_foreach(policy->uid2jailstruct, has_primary_host, &srch);
	*host_result = srch.host_result;
	*jail_result = srch.jail_result;
	
	return *jail_result != NULL && *host_result != NULL;
}

struct jail* policy_get_jail_by_uid(struct policies* policy, int uid) {
	return (struct jail*) g_hash_table_lookup(policy->uid2jailstruct, GINT_TO_POINTER(uid));	
}

// send the host structure in text format to the data stream pointed to by out
gboolean host_write_struct(FILE* fout, struct host* target_host) {	
	GList* key = NULL;
	// dump the host params
	fprintf(fout, "[host#%s]\n", target_host->host_addr);
	fprintf(fout, "action=%s\n", enum2char(target_host->action));
	if (target_host->cmd)
		fprintf(fout, "cmd=%s\n", target_host->cmd);
	if (target_host->execve)
		fprintf(fout, "execve=%s\n", g_strjoinv(";", target_host->execve));
	
	key = target_host->keys;
	while (key && key->data) {
		fprintf(fout, "%s\n", (char*)key->data);
		key = key->next;
	}
	return TRUE;
}

// take the command field in target_host and substitute away any string of type {key with}
// the actual value of the key if it is defined. if not defined, null will be placed
gboolean host_cmd_substition(struct host* target_host, gchar** resultant_cmd, ...) {
	GList *key_node = target_host->keys;
	gchar* s;
	gchar* key = NULL;
	gchar* value = NULL;
	gchar* ret = g_strdup(target_host->cmd);				
	va_list ap;
							
	// FIRST WE DO SUBSTITUTION ON THE VARGS
	va_start(ap, resultant_cmd);
	while (s) {
		gchar *temp;
		s = va_arg(ap, gchar *);
		if (!s)
			break;		
		
		key = str_unpack_key(s);
		value = str_unpack_value(s);
		if (key == NULL || value == NULL) {
			if (key) free(key);
			if (value) free(value);
			g_warning("host_cmd_substition:malformed substition\n");
			continue;
		}		
		
		// case sensitive string replace
		temp = str_replace(ret, key, value);
		g_assert(temp != NULL);
		
		// dump the old return string and replace it with the replaced string
		free(ret);
		free(key);
		free(value);
		
		ret = temp;		
	}    	
	va_end(ap);	
	
	// SECOND WE DO SUBSTITUTION ON THE POLICY FILE PARAMETERS
	while (key_node && key_node->data) {
		gchar *temp;		
		key = str_unpack_key(key_node->data);
		value = str_unpack_value(key_node->data);
		if (key == NULL || value == NULL) {
			if (key) free(key);
			if (value) free(value);
			g_warning("host_cmd_substition:malformed substition\n");
			continue;
		}		
		
		// case sensitive string replace
		temp = str_replace(ret, key, value);
		g_assert(temp != NULL);
		
		// dump the old return string and replace it with the replaced string
		free(ret);
		free(key);
		free(value);
		
		ret = temp;	
		
		key_node = key_node->next;
	}		
	
	*resultant_cmd = ret;
	return TRUE;                                             	
}

struct host* host_new() {
	struct host* ret = malloc(sizeof(struct host));
	memset(ret, 0, sizeof(struct host));
	return ret;
}

gboolean host_new_from_settings(GKeyFile* jail_settings,  gchar* host_string, struct host** host_out) {
	gchar** keys = NULL, **keys_iter = NULL;
	gsize size;
	GError* err = NULL;
	gchar* string_key = NULL;
	gchar** string_list = NULL;	
	gboolean error_free = TRUE;
		
	g_assert(host_out != NULL);
		
 	// we will iterate over all the keys to get and save the mapping
	keys = keys_iter = g_key_file_get_keys(jail_settings, host_string, &size, &err);
	if (keys == NULL) {
		g_warning("get_jail_struct:error during g_key_file_get_keys for %s\n", host_string);
		return FALSE;
	}
	
	// allocate a host structure to hold the resultant
	*host_out = (struct host*)malloc(sizeof(struct host));
	if (*host_out == NULL)
		return FALSE;
	
	memset(*host_out, 0, sizeof(struct host));		// null it

	// get the host address
	if (!SAFE_STRNCPY((*host_out)->host_addr, get_host(host_string), MAX_HOST))
		error_free = FALSE;
			
	while (*keys_iter && error_free == TRUE) {
		error_free = FALSE;				// we are not error free until we extract the key
		string_key = NULL;
		string_key = NULL;
		
		if (strcmp(*keys_iter, "cmd") == 0) {				
			string_key = g_key_file_get_string(jail_settings, host_string, "cmd", &err);
			if (err) break;
				
			if (!SAFE_STRNCPY((*host_out)->cmd, string_key?string_key:"", MAX_HOST)) {
				g_free(string_key);
				break;							
			}
				
			g_free(string_key);
		} else if (strcmp(*keys_iter, "execve") == 0) {
			string_list = g_key_file_get_string_list(jail_settings, host_string, "execve",  &size, &err);
			if (err) break;
									
			if (string_list)	// duplicate the list
				(*host_out)->execve = g_strdupv(string_list);						
				
			g_strfreev(string_list);			
			
		} else if (strcmp(*keys_iter, "action") == 0) {
			string_key = g_key_file_get_string(jail_settings, host_string, "action", &err);
			if (err) break;
				
			(*host_out)->action  = char2enum(string_key);
			g_free(string_key);
			
			if ((*host_out)->action == ERROR)
				break;	
				
		} else {
			gchar* string_key = g_key_file_get_string(jail_settings, host_string, *keys_iter, &err);
			if (err) break;			
			
			// we will collect all the variables that are not a part of the policy defined keys
			(*host_out)->keys = g_list_append((*host_out)->keys, g_strdup_printf("%s=%s", *keys_iter, string_key));					
			g_free(string_key);
		}
		
		error_free = TRUE;
		keys_iter++;
	}
	
	if (error_free == FALSE) {
		if (keys) 		g_strfreev(keys);
		if (*host_out)	host_free(*host_out);
		*host_out = NULL;
		
		g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "host_new_from_settings LEAVE FAILURE\n");
				
		return FALSE;
	}	
	
	return TRUE;
}

// extract the jail structure from the file
gboolean jail_new_from_file(const gchar* dir, gchar* canonical_name, struct jail** jail_out) {
	char jail_path[MAX_PATH+1];
	gsize size;
	gchar** groups = NULL, **groups_iter = NULL;
	GKeyFile* jail_settings = NULL;
	struct host* new_host;
	gboolean error_free = TRUE;
	
	g_assert(jail_out != NULL);
	
	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "jail_new_from_file ENTER\n");
	
	*jail_out = (struct jail*)malloc(sizeof(struct jail));
	if (*jail_out == NULL) {
		g_warning("jail_new_from_file:%s\n", g_strerror(errno));
		return FALSE;
	}
	
	memset(*jail_out, 0, sizeof(struct jail));			
	
	// store the jail canonical name in the jail structure
	if (!SAFE_STRNCPY((*jail_out)->name, canonical_name, MAX_PATH)) {
		g_warning("jail_new_from_file:could not set canonical_name\n");
		free(*jail_out);
		*jail_out = NULL;
		return FALSE;		
	}
	
	// get where this policy is located on disk
	if (!SAFE_SNPRINTF(jail_path, MAX_PATH, "%s/%s", dir, canonical_name)) {
		g_warning("jail_new_from_file:could not concatenate paths\n");
		free(*jail_out);
		*jail_out = NULL;
		return FALSE;
	}
	
	// open the policy file
	jail_settings  = settings_load_from_file(jail_path, FALSE,  FALSE);
	if (jail_settings == NULL) {
		free(*jail_out);
		*jail_out = NULL;
        g_warning("jail_new_from_file:error during open settings %s\n%s\n", jail_path, strerror(errno));
		return FALSE;
	}			
	
	// get all the hosts for the jail
	groups_iter = groups = g_key_file_get_groups(jail_settings, &size);
	if (groups == NULL) {
		free(*jail_out);
		*jail_out = NULL;
		g_key_file_free(jail_settings);
		g_warning("jail_new_from_file:error during g_key_file_get_groups for %s\n", jail_path);
		return FALSE;
	}
	
	// iterate over all the hosts
	while (*groups_iter && error_free == TRUE) {	
		error_free = FALSE;
		
		if (strstr(*groups_iter, "host#") == *groups_iter) {			
			if (!host_new_from_settings(jail_settings, *groups_iter, &new_host))
				break;
											
			(*jail_out)->hosts = g_list_append((*jail_out)->hosts, new_host);	 	// add it to the jail list														
			error_free = TRUE;		
		}		
		groups_iter++;		
	}	
	
	if (error_free == FALSE) {
		g_warning("jail_new_from_file:error during g_key_get_xxxxx:command for %s\n", jail_path);
		jail_free(*jail_out);
		*jail_out = NULL;
	}
	
	g_strfreev(groups);
	g_key_file_free(jail_settings);
	
	g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "jail_new_from_file LEAVE SUCCESS\n");
		
	return error_free;
}

// make a new jail with either an existing name
// or make a jail name which will be of the form <time><uid>
struct jail* policy_create_new_jail(struct policies* in) {
	char new_jail_path[MAX_PATH+1];
	char default_jail_path[MAX_PATH+1];
	char new_jail_name[MAX_PATH+1];
	int uid;
	struct jail* new_jail_struct = NULL;
	GError *err = NULL;
	
	g_assert(in != NULL);
	g_assert(in->settings != NULL);

	// get the user id of a free jail from the jail pool in jail_list
	uid = settings_get_free_jail(in->settings );				
	if (uid == -1) {
		g_warning("policy_create_new_jail:could not allocate a new jail\n");
		return NULL;
	}

	// get the default policy path
	SAFE_SNPRINTF(default_jail_path, MAX_PATH, "%s/default", in->policy_path);
 
	// if jail_name is null, creat a new jail name based on time+uid. otherwise,
	SAFE_SNPRINTF(new_jail_name, MAX_PATH, "%d-%d", (int)time(NULL), uid);

	// associate the new jail name with uid in the jail_mapping table
	if (!settings_set_jail_uid(in->settings , new_jail_name, uid)) {
		g_warning("policy_create_new_jail:could make new assocciation\n");
		return NULL;
	}
	
	// craft a path for the new jail
	if (!SAFE_SNPRINTF(new_jail_path, MAX_PATH, "%s/%s", in->policy_path, new_jail_name)) {
		g_warning("policy_create_new_jail:failure to format new_jail_path\n");
		return NULL;
	}
	
	// copy the file
	if (!copy_file(default_jail_path, new_jail_path))  {
		g_warning("policy_create_new_jail:failed to copy file\n");
		return NULL;	
	}	
	
	// retrieve the new jail structure from the fiile
	if (!jail_new_from_file(in->policy_path, new_jail_name, &new_jail_struct)) {
		g_warning("policy_create_new_jail:failed to load the datastructure from the new policy\n");
		return NULL;
	}
		
	// update the settings file
	settings_save_to_file(in->settings_file, in->settings, &err);						
	if (err) {
		g_warning("policy_create_new_jail: failed to update settings file\n");
		jail_free(new_jail_struct);
		return NULL;
	}
	
	// index the new jail struct by uid
	g_hash_table_insert(in->uid2jailstruct, GINT_TO_POINTER(uid), new_jail_struct);
	return new_jail_struct;	
}

// add a host to the beginning of the jail associated with a given uid. this updates
// the hashes as well 
gboolean policy_prepend_host(struct policies* policy, struct host* new_host, struct jail** target_jail) {				
	gboolean ret = FALSE;
	FILE* original = NULL; 
	FILE* temporary  = NULL;
	char buff[4096+1];
	size_t in_read = 0;
	size_t in_wrote = 0;
	char temporary_path[MAX_PATH+1];
	char original_path[MAX_PATH+1];
	g_assert(target_jail != NULL);
	g_assert(new_host != NULL);
	g_assert(policy != NULL);
	
	// make the temporary path
	if (!SAFE_SNPRINTF(temporary_path, MAX_PATH, "%s/%s_t", policy->policy_path, (*target_jail)->name)) {
		g_warning("policy_prepend_host:could not sprintf temporary_path\n");
		return FALSE;
	}
	
	// make the original path
	if (!SAFE_SNPRINTF(original_path, MAX_PATH, "%s/%s", policy->policy_path, (*target_jail)->name)) {
		g_warning("policy_prepend_host:could not sprintf original_path\n");
		return FALSE;
	}
	
	// make sure the file is not there
	if (access(temporary_path, R_OK) == 0) {
		g_warning("policy_prepend_host:temporary file exists! this is a sign of a big error\n");
		return FALSE;
	}
	
	// copy to a temporary file
	if (!copy_file(original_path, temporary_path)) {
		g_warning("policy_prepend_host:could not copy to a temporary file\n");
		return FALSE;
	}
	
	// kill the original
	if (unlink(original_path) == -1) {
		g_warning("policy_prepend_host:could not delete outdated jail file:%s\n", g_strerror(errno));
		return FALSE;
	}
		
	original = fopen(original_path, "a");
	temporary = fopen(temporary_path, "r");
	
	if (original == NULL || temporary == NULL) {
		if (original) fclose(original);
		if (temporary) fclose(temporary);
		return FALSE;
	}
	

	host_write_struct(original, new_host);
	
	while (!feof(temporary) && !ferror(original) && !ferror(original)) {
		in_wrote = 0;	
		in_read = fread(buff, 1, 4096, temporary);
		while (in_wrote != in_read) {	
			in_wrote = fwrite(buff+in_wrote, 1, in_read-in_wrote, original);
		}
	}
	
	if (original) fclose(original);
	if (temporary)
	{
		ret = feof(temporary);
		fclose(temporary);		
	}
		
	if (unlink(temporary_path) == -1) {
		g_warning("policy_prepend_host:could not delete temporary file:%s\n", g_strerror(errno));
		return FALSE; 
	}
	
	if (ret == FALSE) {
		g_warning("policy_prepend_host:highly inconsistent state!\n");
		return FALSE;
		
	}

	return policy_reload_jail(policy, target_jail);
}

// close the jail and open it again. update the hash and write the changes back to *target
gboolean policy_reload_jail(struct policies* policy, struct jail** target) {
	int uid = -1;
	char jail_name[MAX_PATH+1];
	
	g_assert(policy != NULL);
	
	SAFE_STRNCPY(jail_name, (*target)->name, MAX_PATH);
	
	uid = settings_get_jail_uid(policy->settings, (*target)->name);
	if (uid == -1) 
		g_error("policy_reload_jail:could not reload a jail that does not exist\n");
	
	g_hash_table_remove(policy->uid2jailstruct, GINT_TO_POINTER(uid));	
	jail_free(*target);
	
	if (!jail_new_from_file(policy->policy_path, jail_name, target)) {
		g_warning("policy_reload_jail:could not read the jail\n");
		return FALSE;
	}
	
	// update the hash
	g_hash_table_insert(policy->uid2jailstruct, GINT_TO_POINTER(uid), *target);
	return TRUE;
	
}

// return uid of a free jail
static int settings_get_free_jail(GKeyFile* settings) {
	gchar** jails = NULL;
	gchar** jails_iter;
	GError *err= NULL;
	gsize length;	

	// get the list of all uids
	jails_iter = jails = g_key_file_get_keys(settings, "jail_list",  &length, &err);
	if (err) {
		g_error("settings_get_free_jail:could not get the list of jails!\n");
		g_strfreev(jails);
		return -1;
	}       
	                           
	// iterate through all uids and find a free one    	
	while (*jails_iter) {
		// if the jail is not assigned, return the uid
		if (jail_is_assigned(settings, atoi(*jails_iter)) == FALSE) {
			int ret = atoi(*jails_iter);
			// free up the buffer
			g_strfreev(jails);
			return ret;
		}
												
		// move to the next uid							
		jails_iter++;			
	}
	
	// free up the buffer
	if (jails) g_strfreev(jails);
	
	g_warning("settings_get_free_jail:no free jails remain\n");
	
	return -1;
}
 
// path must be MAX_PATH long
// returns the length of path string
int settings_get_jail_path(GKeyFile* settings, int uid, gchar* path) {
	GError* err = NULL;
	gchar str_uid[256];
	gchar* ret = NULL;
	
	SAFE_SNPRINTF(str_uid, 256, "%d", uid);
		
	ret = g_key_file_get_string(settings, "jail_list", str_uid, &err);
	if (err)
		return -1;
	
	if (!SAFE_STRNCPY(path, ret, MAX_PATH)) {
		g_warning("settings_get_jail_path:could not save the result\n");
	}
	
	return strlen(ret);	
}

// is there a jail assigned to uid?
static gboolean jail_is_assigned(GKeyFile* settings, int uid) {	
	gsize length;
	GError* err = NULL;
	gchar** jails = NULL;
	gchar** jails_iter = NULL;
	
	// get all the jail canonical names
	jails = jails_iter = g_key_file_get_keys(settings, "jail_mapping", &length, &err);
	if (*jails == NULL)
		return FALSE;
	
	// iterate through all the canonicals
	// and see if any of them are mapped to this given uid
	// if so, return TRUE
	while (*jails_iter) {
		if (settings_get_jail_uid(settings, *jails_iter) == uid) {
			if (jails) g_strfreev(jails);
			return TRUE;
		}
		
		jails_iter++;
	}
	
	// free up the buffer
	if (jails) g_strfreev(jails);
	return FALSE;
}

// find which uid the canonical jail is mapped to
int settings_get_jail_uid(GKeyFile* settings, const gchar* jail_name) {
	int ret;
	GError *err = NULL;

	ret = g_key_file_get_integer(settings, "jail_mapping", jail_name, &err);
	if (err != NULL)
		ret = -1; 

	return ret;
}

// associate a canonical jail name with uid
static gboolean settings_set_jail_uid(GKeyFile* settings, const gchar* jail_name, int uid) {
	g_key_file_set_integer(settings, "jail_mapping", jail_name, uid);		
	return TRUE;
}


// copy the file
static gboolean copy_file(const gchar* source, const gchar* destination) {
	FILE* in = fopen(source, "r");
	FILE* out = fopen(destination, "a");
	char buff[4096+1];
	size_t in_read = 0;
	size_t in_wrote = 0;
	gboolean is_eof;
	
	if (in == NULL || out == NULL) {
		if (in) fclose(in);
		if (out) fclose(out);
		return FALSE;
	}
	
	while (!feof(in) && !ferror(in) && !ferror(out)) {
		in_wrote = 0;	
		in_read = fread(buff, 1, 4096, in);
		while (in_wrote != in_read) {	
			in_wrote = fwrite(buff+in_wrote, 1, in_read-in_wrote, out);
		}
	}

	is_eof = feof(in);
		
	// DEBUGGING ASSERT
	g_assert(ferror(in) == FALSE);
	g_assert(ferror(out) == FALSE);
	
	if (in) fclose(in);
	if (out) fclose(out);			
	
	return is_eof == TRUE;
}

gchar* str_pack_key_value(const gchar* key_string, const gchar* value_string){
	return g_strdup_printf("%s=%s", key_string, value_string);
}


// get key from key=value. make sure to free resultant
gchar* str_unpack_key(const gchar* key_string){
	gchar* eq = NULL;
	gchar* ret;
	if ((eq = strchr(key_string, '='))) {
		ret = malloc(eq - key_string + 1);
		if (ret == NULL)
			return NULL;
		
		strncpy(ret, key_string, eq - key_string);
		ret[eq-key_string] = 0x00;		
		return ret;
	}
	return NULL;
}

// get value from key=value make sure to free resultant
gchar* str_unpack_value(const gchar* key_string) {
	gchar* eq = NULL;
	gchar* ret;
	int key_string_length = strlen(key_string);
	if ((eq = strchr(key_string, '='))) {
		ret = malloc(key_string_length - (key_string - eq));
		if (ret == NULL)
			return NULL;
		
		strncpy(ret, eq+1, key_string_length - (key_string - eq));
		return ret;
	}
	return NULL;
}

// replace one instance of from with to in str str
gchar* str_replace(const gchar* str, const gchar* from, const gchar* to) {
	gchar* resultant = NULL;
	int str_length = strlen(str);
	int from_length = strlen(from);
	int to_length = strlen(to);
	
	gchar* loc_substr = NULL;
	 
	if ((loc_substr = strstr(str, from))) {
		int head_size = loc_substr - str;
		int tail_size = str_length - head_size - from_length + 1;
		
		g_assert(str_length + to_length - from_length + 1 > 0);
		resultant = (gchar*)malloc(str_length + to_length - from_length + 1);
		// copy the beginning of the string
		memcpy(resultant, str, head_size);
		// copy the replacement
		memcpy(head_size + resultant, to, to_length);
		// copy the tail (+1 for 0x00)
		memcpy(head_size + resultant + to_length, loc_substr + from_length, tail_size);		
		return resultant;
	} else {	
		return g_strdup(str);
	}
}