/*
 * Author: Karl MacMillan <kmacmillan@tresys.com>
 *
 * Modified:  
 *   Dan Walsh <dwalsh@redhat.com> - Added security_load_booleans().
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <stdlib.h>
#include <dirent.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fnmatch.h>
#include <limits.h>
#include <ctype.h>
#include <errno.h>

#include "selinux_internal.h"
#include "policy.h"

#define SELINUX_BOOL_DIR "/booleans/"

static int filename_select(const struct dirent *d)
{
	int len;

	len = strlen(d->d_name);
	if (len == 1 && d->d_name[0] == '.')
		return 0;
	if (len == 2 && d->d_name[0] == '.' &&
	    d->d_name[1] == '.')
		return 0;
	return 1;
}

int security_get_boolean_names(char ***names, int *len)
{
	char path[PATH_MAX];
	int i, rc;
	struct dirent **namelist;
	char **n;

	assert(len);
	if (!selinux_mnt) {
		errno = ENOENT;
		return -1;
	}

	snprintf(path, sizeof path, "%s%s", selinux_mnt, SELINUX_BOOL_DIR);
	*len = scandir(path, &namelist, &filename_select,
		       alphasort);
	if (*len <= 0) {
		return -1;
	}

	n = (char**)malloc(sizeof(char*) * *len);
	if (!n) {
		rc = -1;
		goto bad;
	}

	memset(n, 0, sizeof(char*) * *len);
	
	for (i = 0; i < *len; i++) {
		n[i] = (char*)malloc(sizeof(char)
				     * (namelist[i]->d_reclen + 1));
		if (!n[i]) {
			rc = -1;
			goto bad_freen;
		}
		strncpy(n[i], namelist[i]->d_name, namelist[i]->d_reclen + 1);
	}
	rc = 0;
	*names = n;
out:
	for (i = 0; i < *len; i++) {
		free(namelist[i]);
	}
	free(namelist);
	return rc;
bad_freen:
	for (i = 0; i < *len; i++) {
		if (n[i])
			free(n[i]);
	}
	free(n);
bad:
	goto out;
}
hidden_def(security_get_boolean_names)

#define STRBUF_SIZE 3 
static int get_bool_value(const char *name, char **buf)
{
	int fd, len;
	char *fname = NULL;

	if (!selinux_mnt) {
		errno = ENOENT;
		return -1;
	}

	*buf = (char*)malloc(sizeof(char) * (STRBUF_SIZE + 1));
	if (!*buf)
		goto out;
	(*buf)[STRBUF_SIZE] = 0;

	len = strlen(name) + strlen(selinux_mnt) + sizeof(SELINUX_BOOL_DIR);
	fname = (char*)malloc(sizeof(char) * len);
	if (!fname)
		goto out;
	snprintf(fname, len, "%s%s%s", selinux_mnt, SELINUX_BOOL_DIR, name);

	fd = open(fname, O_RDONLY);
	if (fd < 0)
		goto out;

	len = read(fd, *buf, STRBUF_SIZE);
	close(fd);
	if (len != STRBUF_SIZE)
		goto out;

	free(fname);
	return 0;
out:
	if (*buf)
		free(*buf);
	if (fname)
		free(fname);
	return -1;
}

int security_get_boolean_pending(const char *name)
{
	char *buf;
	int val;

	if (get_bool_value(name, &buf))
		return -1;

	if (atoi(&buf[1]))
		val = 1;
	else
		val = 0;
	free(buf);
	return val;
}

int security_get_boolean_active(const char *name)
{
	char *buf;
	int val;

	if (get_bool_value(name, &buf))
		return -1;

	buf[1] = '\0';
	if (atoi(buf))
		val = 1;
	else
		val = 0;
	free(buf);
	return val;
}
hidden_def(security_get_boolean_active)

int security_set_boolean(const char *name, int value)
{
	int fd, ret, len;
	char buf[2], *fname;

	if (!selinux_mnt) {
		errno = ENOENT;
		return -1;
	}
	if ( value < 0 || value > 1 ) {
		errno = EINVAL;
		return -1;
	}

	len = strlen(name) + strlen(selinux_mnt) + sizeof(SELINUX_BOOL_DIR);
	fname = (char*)malloc(sizeof(char) * len);
	if (!fname)
		return -1;
	snprintf(fname, len, "%s%s%s", selinux_mnt, SELINUX_BOOL_DIR, name);

	fd = open(fname, O_WRONLY);
	if (fd < 0) {
		ret = -1;
		goto out;
	}

	if (value)
		buf[0] = '1';
	else
		buf[0] = '0';
	buf[1] = '\0';
	
	ret = write(fd, buf, 2);
	close(fd);
out:
	free(fname);
	if (ret > 0)
		return 0;
	else
		return -1;
}
hidden_def(security_set_boolean)

int security_commit_booleans(void)
{
	int fd, ret;
	char buf[2];
	char path[PATH_MAX];

	if (!selinux_mnt) {
		errno = ENOENT;
		return -1;
	}

	snprintf(path, sizeof path, "%s/commit_pending_bools", selinux_mnt);
	fd = open(path, O_WRONLY);
	if (fd < 0)
		return -1;

	buf[0] = '1';
	buf[1] = '\0';
	
	ret = write(fd, buf, 2);
	close(fd);

	if (ret > 0)
		return 0;
	else
		return -1;
}
hidden_def(security_commit_booleans)

static char *strtrim(char *dest, char *source, int size) {
	int i=0;
	char *ptr=source;
	i=0;
	while(isspace(*ptr) && i < size) {
		ptr++;
		i++;
	}
	strncpy(dest,ptr,size);
	for(i=strlen(dest)-1; i> 0; i--) {
		if (!isspace(dest[i])) break;
	}
	dest[i+1]='\0';
	return dest;
}
static int process_boolean(char *buffer, char *name, int namesize, int *val) {
	char name1[BUFSIZ];
	char *ptr;
	char *tok=strtok_r(buffer,"=",&ptr);
	if (tok) {
		strncpy(name1,tok, BUFSIZ-1);
		strtrim(name,name1,namesize-1);
		if ( name[0]=='#' ) return 0;
		tok=strtok_r(NULL,"\0",&ptr);
		if (tok) {
			while (isspace(*tok)) tok++;
			*val = -1;
			if (isdigit(tok[0]))
				*val=atoi(tok);
			else if (!strncasecmp(tok, "true", sizeof("true")-1))
				*val = 1;
			else if (!strncasecmp(tok, "false", sizeof("false")-1))
				*val = 0;
			if (*val != 0 && *val != 1) {
				errno=EINVAL;
				return -1;
			}
			
		}
	}
	return 1;
}
static int save_booleans(size_t boolcnt, SELboolean *boollist) {
	ssize_t len;
	size_t i;
	char outbuf[BUFSIZ];
	char *inbuf=NULL;
	
	/* Open file */
	const char *bool_file = selinux_booleans_path();
	char local_bool_file[PATH_MAX];
	char tmp_bool_file[PATH_MAX]; 
	FILE *boolf;
	int fd;
	int *used= (int *) malloc (sizeof(int) * boolcnt);
	if (! used) {
		return -1;
	}
	/* zero out used field */
	for (i=0; i < boolcnt; i++)
		used[i]=0;


	snprintf(tmp_bool_file,sizeof(tmp_bool_file),"%s.XXXXXX", bool_file);
	fd = mkstemp(tmp_bool_file);
	if (fd < 0) { 
		free(used);
		return -1;
	}

	snprintf(local_bool_file,sizeof(local_bool_file),"%s.local", bool_file);	boolf = fopen(local_bool_file,"r");
	if (boolf != NULL) {
		ssize_t ret;
		size_t size=0;
		int val;
		char boolname[BUFSIZ];
		char *buffer;
		char *inbuf=NULL;
		while ((len=getline(&inbuf, &size, boolf)) > 0) {
			buffer=strdup(inbuf);
			if (!buffer) goto close_remove_fail;
			ret=process_boolean(inbuf, boolname, sizeof(boolname), &val);
			if (ret!=1) { 
				ret=write(fd, buffer, len);
				free(buffer);
				if (ret != len) 
					goto close_remove_fail;
			} else {
				free(buffer);
				for (i=0; i < boolcnt; i++) {
					if (strcmp(boollist[i].name, boolname)==0) {
						snprintf(outbuf,sizeof(outbuf), "%s=%d\n", boolname, boollist[i].value); 
						len=strlen(outbuf);
						used[i]=1;
						if (write(fd, outbuf, len) != len) 
							goto close_remove_fail;
						else 
							break;
					}
				}
				if ( i == boolcnt ) {
					snprintf(outbuf,sizeof(outbuf), "%s=%d\n", boolname, val); 
					len=strlen(outbuf);
					if (write(fd, outbuf, len) != len) 
						goto close_remove_fail;
				}
			}
			free(inbuf);
			inbuf=NULL;
		}
		fclose(boolf);
	}
	
	for (i=0; i < boolcnt; i++) {
		if (used[i]==0) {
			snprintf(outbuf,sizeof(outbuf), "%s=%d\n", boollist[i].name, boollist[i].value); 
			len=strlen(outbuf);
			if (write(fd, outbuf, len) != len) {
			close_remove_fail:
				free(inbuf);
				close(fd);
			remove_fail:
				unlink(tmp_bool_file);
				free(used);
				return -1;
			}
		}
		
	}
	if (fchmod(fd, S_IRUSR | S_IWUSR) != 0)
		goto close_remove_fail;
	close(fd);
	if (rename(tmp_bool_file, local_bool_file) != 0)
		goto remove_fail;

	free(used);
	return 0;
}
static void rollback(SELboolean *boollist, int end)
{
	int i;

        for(i=0; i<end; i++)
                security_set_boolean(boollist[i].name,
                        security_get_boolean_active(boollist[i].name));
}


int security_set_boolean_list(size_t boolcnt, SELboolean *boollist, int permanent) {

	size_t i;
	for (i=0; i < boolcnt; i++) {
		if(security_set_boolean(boollist[i].name, boollist[i].value)) {
			rollback(boollist, i);
			return -1;
		}
	}

	/* OK, let's do the commit */
	if (security_commit_booleans()) {
		return -1;
	}

	if (permanent) 
		return save_booleans(boolcnt, boollist);

	return 0;
}
int security_load_booleans(char *path) {
	FILE *boolf;
	char *inbuf;
	char localbools[BUFSIZ];
	size_t len=0, errors=0;
	int val;
	char name[BUFSIZ];

	boolf = fopen(path ? path : selinux_booleans_path(),"r");
	if (boolf == NULL) 
	  goto localbool;

	while (getline(&inbuf, &len, boolf) > 0) {
		int ret=process_boolean(inbuf, name, sizeof(name), &val);
		if (ret==-1) 
			errors++;
		if (ret==1) 
			if (security_set_boolean(name, val) < 0) {
				errors++;
			}
	}
	fclose(boolf);
localbool:
	snprintf(localbools,sizeof(localbools), "%s.local", (path ? path : selinux_booleans_path()));
	boolf = fopen(localbools,"r");

	if (boolf != NULL) {
		int ret;
		while (getline(&inbuf, &len, boolf) > 0) {
			ret=process_boolean(inbuf, name, sizeof(name), &val);
			if (ret==-1) 
				errors++;
			if (ret==1) 
				if (security_set_boolean(name, val) < 0) {
					errors++;
				}
		}
		fclose(boolf);
	}
	if (security_commit_booleans() < 0)
		return -1;

	if (errors)
		errno = EINVAL;
	return errors ? -1 : 0;
}