database_policydb.c

/* Copyright (C) 2005 Red Hat, Inc. */

/* Object: dbase_policydb_t (Policy)
 * Implements: dbase_t (Database)
 */

struct dbase_policydb;
typedef struct dbase_policydb dbase_t;
#define DBASE_DEFINED

#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <errno.h>

#include <sepol/policydb.h>

#include "database_policydb.h"
#include "semanage_store.h"
#include "handle.h"
#include "debug.h"

/* POLICYDB dbase */
struct dbase_policydb {

        /* Backing path for read-only[0] and transaction[1] */
        const char *path[2];

	/* Base record table */
	record_table_t *rtable;

	/* Policy extensions */
	record_policydb_table_t *rptable;

	sepol_policydb_t *policydb;

	int cache_serial;
	int modified;
	int attached;
};

static void dbase_policydb_drop_cache(dbase_policydb_t * dbase)
{

	if (dbase->cache_serial >= 0) {
		sepol_policydb_free(dbase->policydb);
		dbase->cache_serial = -1;
		dbase->modified = 0;
	}
}

static int dbase_policydb_set_serial(semanage_handle_t * handle,
				     dbase_policydb_t * dbase)
{

	int cache_serial = handle->funcs->get_serial(handle);
	if (cache_serial < 0) {
		ERR(handle, "could not update cache serial");
		return STATUS_ERR;
	}

	dbase->cache_serial = cache_serial;
	return STATUS_SUCCESS;
}

static int dbase_policydb_needs_resync(semanage_handle_t * handle,
				       dbase_policydb_t * dbase)
{

	int cache_serial;

	if (dbase->cache_serial < 0)
		return 1;

	cache_serial = handle->funcs->get_serial(handle);
	if (cache_serial < 0)
		return 1;

	if (cache_serial != dbase->cache_serial) {
		dbase_policydb_drop_cache(dbase);
		dbase->cache_serial = -1;
		return 1;
	}
	return 0;
}

static int dbase_policydb_cache(semanage_handle_t * handle,
				dbase_policydb_t * dbase)
{

	FILE *fp = NULL;
	sepol_policydb_t *policydb = NULL;
	sepol_policy_file_t *pf = NULL;
	const char *fname = NULL;

	/* Check if cache is needed */
	if (dbase->attached)
		return STATUS_SUCCESS;

	if (!dbase_policydb_needs_resync(handle, dbase))
		return STATUS_SUCCESS;

	fname = dbase->path[handle->is_in_transaction];

	if (sepol_policydb_create(&policydb) < 0) {
		ERR(handle, "could not create policydb object");
		goto err;
	}

	/* Try opening file 
	 * ENOENT is not fatal - we just create an empty policydb */
	fp = fopen(fname, "rb");
	if (fp == NULL && errno != ENOENT) {
		ERR(handle, "could not open %s for reading: %s",
		    fname, strerror(errno));
		goto err;
	}

	/* If the file was opened successfully, read a policydb */
	if (fp != NULL) {
		__fsetlocking(fp, FSETLOCKING_BYCALLER);
		if (sepol_policy_file_create(&pf) < 0) {
			ERR(handle, "could not create policy file object");
			goto err;
		}

		sepol_policy_file_set_fp(pf, fp);
		sepol_policy_file_set_handle(pf, handle->sepolh);

		if (sepol_policydb_read(policydb, pf) < 0)
			goto err;

		sepol_policy_file_free(pf);
		fclose(fp);
		fp = NULL;
	}

	/* Update cache serial */
	if (dbase_policydb_set_serial(handle, dbase) < 0)
		goto err;

	/* Update the database policydb */
	dbase->policydb = policydb;
	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not cache policy database");
	if (fp)
		fclose(fp);
	sepol_policydb_free(policydb);
	sepol_policy_file_free(pf);
	return STATUS_ERR;
}

static int dbase_policydb_flush(semanage_handle_t * handle
				__attribute__ ((unused)),
				dbase_policydb_t * dbase)
{

	if (!dbase->modified)
		return STATUS_SUCCESS;

	dbase->modified = 0;

	/* Stub */
	return STATUS_ERR;
}

/* Check if modified */
static int dbase_policydb_is_modified(dbase_policydb_t * dbase)
{

	return dbase->modified;
}

int dbase_policydb_init(semanage_handle_t * handle,
			const char *path_ro,
			const char *path_rw,
			record_table_t * rtable,
			record_policydb_table_t * rptable,
			dbase_policydb_t ** dbase)
{

	dbase_policydb_t *tmp_dbase =
	    (dbase_policydb_t *) malloc(sizeof(dbase_policydb_t));

	if (!tmp_dbase)
		goto omem;

	tmp_dbase->path[0] = path_ro;
	tmp_dbase->path[1] = path_rw;
	tmp_dbase->rtable = rtable;
	tmp_dbase->rptable = rptable;
	tmp_dbase->policydb = NULL;
	tmp_dbase->cache_serial = -1;
	tmp_dbase->modified = 0;
	tmp_dbase->attached = 0;
	*dbase = tmp_dbase;

	return STATUS_SUCCESS;

      omem:
	ERR(handle, "out of memory, could not initialize policy database");
	free(tmp_dbase);

	return STATUS_ERR;
}

/* Release dbase resources */
void dbase_policydb_release(dbase_policydb_t * dbase)
{

	dbase_policydb_drop_cache(dbase);
	free(dbase);
}

/* Attach to a shared policydb.
 * This implies drop_cache(),
 * and prevents flush() and drop_cache()
 * until detached. */
void dbase_policydb_attach(dbase_policydb_t * dbase,
			   sepol_policydb_t * policydb)
{

	dbase->attached = 1;
	dbase_policydb_drop_cache(dbase);
	dbase->policydb = policydb;
}

/* Detach from a shared policdb.
 * This implies drop_cache. */
void dbase_policydb_detach(dbase_policydb_t * dbase)
{

	dbase->attached = 0;
	dbase->modified = 0;
}

static int dbase_policydb_add(semanage_handle_t * handle,
			      dbase_policydb_t * dbase,
			      const record_key_t * key, const record_t * data)
{

	if (dbase->rptable->add(handle->sepolh, dbase->policydb, key, data) < 0)
		goto err;

	dbase->modified = 1;
	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not add record to the database");
	return STATUS_ERR;
}

static int dbase_policydb_set(semanage_handle_t * handle,
			      dbase_policydb_t * dbase,
			      const record_key_t * key, const record_t * data)
{

	if (dbase->rptable->set(handle->sepolh, dbase->policydb, key, data) < 0)
		goto err;

	dbase->modified = 1;
	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not set record value");
	return STATUS_ERR;
}

static int dbase_policydb_modify(semanage_handle_t * handle,
				 dbase_policydb_t * dbase,
				 const record_key_t * key,
				 const record_t * data)
{

	if (dbase->rptable->modify(handle->sepolh,
				   dbase->policydb, key, data) < 0)
		goto err;

	dbase->modified = 1;
	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not modify record value");
	return STATUS_ERR;
}

static int dbase_policydb_del(semanage_handle_t * handle
				__attribute__ ((unused)),
			      dbase_policydb_t * dbase
				__attribute__ ((unused)),
			      const record_key_t * key
				__attribute__ ((unused)))
{

	/* Stub */
	return STATUS_ERR;
}

static int dbase_policydb_clear(semanage_handle_t * handle
				__attribute__ ((unused)),
				dbase_policydb_t * dbase
				__attribute__ ((unused)))
{

	/* Stub */
	return STATUS_ERR;
}

static int dbase_policydb_query(semanage_handle_t * handle,
				dbase_policydb_t * dbase,
				const record_key_t * key, record_t ** response)
{

	if (dbase->rptable->query(handle->sepolh,
				  dbase->policydb, key, response) < 0)
		goto err;

	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not query record value");
	return STATUS_ERR;
}

static int dbase_policydb_exists(semanage_handle_t * handle,
				 dbase_policydb_t * dbase,
				 const record_key_t * key, int *response)
{

	if (dbase->rptable->exists(handle->sepolh,
				   dbase->policydb, key, response) < 0)
		goto err;

	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not check if record exists");
	return STATUS_ERR;
}

static int dbase_policydb_count(semanage_handle_t * handle,
				dbase_policydb_t * dbase,
				unsigned int *response)
{

	if (dbase->rptable->count(handle->sepolh,
				  dbase->policydb, response) < 0)
		goto err;

	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not count the database records");
	return STATUS_ERR;
}

static int dbase_policydb_iterate(semanage_handle_t * handle,
				  dbase_policydb_t * dbase,
				  int (*fn) (const record_t * record,
					     void *fn_arg), void *arg)
{

	if (dbase->rptable->iterate(handle->sepolh,
				    dbase->policydb, fn, arg) < 0)
		goto err;

	return STATUS_SUCCESS;

      err:
	ERR(handle, "could not iterate over records");
	return STATUS_ERR;
}

struct list_handler_arg {
	semanage_handle_t *handle;
	record_table_t *rtable;
	record_t **records;
	int pos;
};

static int list_handler(const record_t * record, void *varg)
{

	struct list_handler_arg *arg = (struct list_handler_arg *)varg;

	if (arg->rtable->clone(arg->handle, record, &arg->records[arg->pos]) <
	    0)
		return -1;
	arg->pos++;
	return 0;
}

static int dbase_policydb_list(semanage_handle_t * handle,
			       dbase_t * dbase,
			       record_t *** records, unsigned int *count)
{

	record_t **tmp_records = NULL;
	unsigned int tmp_count;
	struct list_handler_arg list_arg;
	list_arg.pos = 0;
	list_arg.rtable = dbase->rtable;
	list_arg.handle = handle;

	if (dbase->rptable->count(handle->sepolh,
				  dbase->policydb, &tmp_count) < 0)
		goto err;

	if (tmp_count > 0) {
		tmp_records = (record_t **)
		    calloc(tmp_count, sizeof(record_t *));

		if (tmp_records == NULL)
			goto omem;

		list_arg.records = tmp_records;

		if (dbase->rptable->iterate(handle->sepolh,
					    dbase->policydb, list_handler,
					    &list_arg) < 0) {
			ERR(handle, "list handler could not extract record");
			goto err;
		}
	}

	*records = tmp_records;
	*count = tmp_count;
	return STATUS_SUCCESS;

      omem:
	ERR(handle, "out of memory");

      err:
	if (tmp_records) {
		for (; list_arg.pos >= 0; list_arg.pos--)
			dbase->rtable->free(tmp_records[list_arg.pos]);
		free(tmp_records);
	}
	ERR(handle, "could not list records");
	return STATUS_ERR;
}

static record_table_t *dbase_policydb_get_rtable(dbase_policydb_t * dbase)
{

	return dbase->rtable;
}

/* POLICYDB dbase - method table implementation */
dbase_table_t SEMANAGE_POLICYDB_DTABLE = {

	/* Cache/Transactions */
	.cache = dbase_policydb_cache,
	.drop_cache = dbase_policydb_drop_cache,
	.flush = dbase_policydb_flush,
	.is_modified = dbase_policydb_is_modified,

	/* Database Functionality */
	.iterate = dbase_policydb_iterate,
	.exists = dbase_policydb_exists,
	.list = dbase_policydb_list,
	.add = dbase_policydb_add,
	.set = dbase_policydb_set,
	.del = dbase_policydb_del,
	.clear = dbase_policydb_clear,
	.modify = dbase_policydb_modify,
	.query = dbase_policydb_query,
	.count = dbase_policydb_count,

	/* Polymorphism */
	.get_rtable = dbase_policydb_get_rtable
};