/* Author: Jason Tang	  <jtang@tresys.com>

 *         Christopher Ashworth <cashworth@tresys.com>

 *

 * Copyright (C) 2004-2006 Tresys Technology, LLC

 * Copyright (C) 2005 Red Hat, Inc.

 * 

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2.1 of the License, or (at your option) any later version.

 *

 *  This library 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

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <sepol/module.h>

#include <sepol/handle.h>

#include <sepol/cil/cil.h>

#include <selinux/selinux.h>

#include <assert.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdio_ext.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <limits.h>

#include <errno.h>

#include <dirent.h>

#include "user_internal.h"

#include "seuser_internal.h"

#include "port_internal.h"

#include "ibpkey_internal.h"

#include "ibendport_internal.h"

#include "iface_internal.h"

#include "boolean_internal.h"

#include "fcontext_internal.h"

#include "node_internal.h"

#include "genhomedircon.h"

#include "debug.h"

#include "handle.h"

#include "modules.h"

#include "direct_api.h"

#include "semanage_store.h"

#include "database_policydb.h"

#include "policy.h"

#include <sys/mman.h>

#include <sys/wait.h>

#define PIPE_READ 0

#define PIPE_WRITE 1

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

static void semanage_direct_destroy(semanage_handle_t * sh);

static int semanage_direct_disconnect(semanage_handle_t * sh);

static int semanage_direct_begintrans(semanage_handle_t * sh);

static int semanage_direct_commit(semanage_handle_t * sh);

static int semanage_direct_install(semanage_handle_t * sh, char *data,

				   size_t data_len, const char *module_name, const char *lang_ext);

static int semanage_direct_install_file(semanage_handle_t * sh, const char *module_name);

static int semanage_direct_extract(semanage_handle_t * sh,

					   semanage_module_key_t *modkey,

					   int extract_cil,

					   void **mapped_data,

					   size_t *data_len,

					   semanage_module_info_t **modinfo);

static int semanage_direct_remove(semanage_handle_t * sh, char *module_name);

static int semanage_direct_list(semanage_handle_t * sh,

				semanage_module_info_t ** modinfo,

				int *num_modules);

static int semanage_direct_get_enabled(semanage_handle_t *sh,

				       const semanage_module_key_t *modkey,

				       int *enabled);

static int semanage_direct_set_enabled(semanage_handle_t *sh,

				       const semanage_module_key_t *modkey,

				       int enabled);

static int semanage_direct_get_module_info(semanage_handle_t *sh,

					   const semanage_module_key_t *modkey,

					   semanage_module_info_t **modinfo);

static int semanage_direct_list_all(semanage_handle_t *sh,

				    semanage_module_info_t **modinfo,

				    int *num_modules);

static int semanage_direct_install_info(semanage_handle_t *sh,

					const semanage_module_info_t *modinfo,

					char *data,

					size_t data_len);

static int semanage_direct_remove_key(semanage_handle_t *sh,

				      const semanage_module_key_t *modkey);

static struct semanage_policy_table direct_funcs = {

	.get_serial = semanage_direct_get_serial,

	.destroy = semanage_direct_destroy,

	.disconnect = semanage_direct_disconnect,

	.begin_trans = semanage_direct_begintrans,

	.commit = semanage_direct_commit,

	.install = semanage_direct_install,

	.extract = semanage_direct_extract,

	.install_file = semanage_direct_install_file,

	.remove = semanage_direct_remove,

	.list = semanage_direct_list,

	.get_enabled = semanage_direct_get_enabled,

	.set_enabled = semanage_direct_set_enabled,

	.get_module_info = semanage_direct_get_module_info,

	.list_all = semanage_direct_list_all,

	.install_info = semanage_direct_install_info,

	.remove_key = semanage_direct_remove_key,

};

int semanage_direct_is_managed(semanage_handle_t * sh)

{

	if (semanage_check_init(sh, sh->conf->store_root_path))

		goto err;

	if (semanage_access_check(sh) < 0)

		return 0;

	return 1;

      err:

	ERR(sh, "could not check whether policy is managed");

	return STATUS_ERR;

}

/* Check that the module store exists, creating it if necessary.

 */

int semanage_direct_connect(semanage_handle_t * sh)

{

	const char *path;

	struct stat sb;

	if (semanage_check_init(sh, sh->conf->store_root_path))

		goto err;

	if (sh->create_store)

		if (semanage_create_store(sh, 1))

			goto err;

	sh->u.direct.translock_file_fd = -1;

	sh->u.direct.activelock_file_fd = -1;

	/* set up function pointers */

	sh->funcs = &direct_funcs;

	/* Object databases: local modifications */

	if (user_base_file_dbase_init(sh,

				      semanage_path(SEMANAGE_ACTIVE,

						    SEMANAGE_USERS_BASE_LOCAL),

				      semanage_path(SEMANAGE_TMP,

						    SEMANAGE_USERS_BASE_LOCAL),

				      semanage_user_base_dbase_local(sh)) < 0)

		goto err;

	if (user_extra_file_dbase_init(sh,

				       semanage_path(SEMANAGE_ACTIVE,

						     SEMANAGE_USERS_EXTRA_LOCAL),

				       semanage_path(SEMANAGE_TMP,

						     SEMANAGE_USERS_EXTRA_LOCAL),

				       semanage_user_extra_dbase_local(sh)) < 0)

		goto err;

	if (user_join_dbase_init(sh,

				 semanage_user_base_dbase_local(sh),

				 semanage_user_extra_dbase_local(sh),

				 semanage_user_dbase_local(sh)) < 0)

		goto err;

	if (port_file_dbase_init(sh,

				 semanage_path(SEMANAGE_ACTIVE,

					       SEMANAGE_PORTS_LOCAL),

				 semanage_path(SEMANAGE_TMP,

					       SEMANAGE_PORTS_LOCAL),

				 semanage_port_dbase_local(sh)) < 0)

		goto err;

	if (iface_file_dbase_init(sh,

				  semanage_path(SEMANAGE_ACTIVE,

						SEMANAGE_INTERFACES_LOCAL),

				  semanage_path(SEMANAGE_TMP,

						SEMANAGE_INTERFACES_LOCAL),

				  semanage_iface_dbase_local(sh)) < 0)

		goto err;

	if (bool_file_dbase_init(sh,

				 semanage_path(SEMANAGE_ACTIVE,

					       SEMANAGE_BOOLEANS_LOCAL),

				 semanage_path(SEMANAGE_TMP,

					       SEMANAGE_BOOLEANS_LOCAL),

				 semanage_bool_dbase_local(sh)) < 0)

		goto err;

	if (fcontext_file_dbase_init(sh,

				     semanage_path(SEMANAGE_ACTIVE, SEMANAGE_STORE_FC_LOCAL),

				     semanage_path(SEMANAGE_TMP, SEMANAGE_STORE_FC_LOCAL),

				     semanage_fcontext_dbase_local(sh)) < 0)

		goto err;

	if (fcontext_file_dbase_init(sh,

				     semanage_path(SEMANAGE_ACTIVE, SEMANAGE_STORE_FC_HOMEDIRS),

				     semanage_path(SEMANAGE_TMP, SEMANAGE_STORE_FC_HOMEDIRS),

				     semanage_fcontext_dbase_homedirs(sh)) < 0)

		goto err;

	if (seuser_file_dbase_init(sh,

				   semanage_path(SEMANAGE_ACTIVE,

						 SEMANAGE_SEUSERS_LOCAL),

				   semanage_path(SEMANAGE_TMP,

						 SEMANAGE_SEUSERS_LOCAL),

				   semanage_seuser_dbase_local(sh)) < 0)

		goto err;

	if (node_file_dbase_init(sh,

				 semanage_path(SEMANAGE_ACTIVE,

					       SEMANAGE_NODES_LOCAL),

				 semanage_path(SEMANAGE_TMP,

					       SEMANAGE_NODES_LOCAL),

				 semanage_node_dbase_local(sh)) < 0)

		goto err;

	if (ibpkey_file_dbase_init(sh,

				   semanage_path(SEMANAGE_ACTIVE,

					         SEMANAGE_IBPKEYS_LOCAL),

				   semanage_path(SEMANAGE_TMP,

					         SEMANAGE_IBPKEYS_LOCAL),

				   semanage_ibpkey_dbase_local(sh)) < 0)

		goto err;

	if (ibendport_file_dbase_init(sh,

				      semanage_path(SEMANAGE_ACTIVE,

						    SEMANAGE_IBENDPORTS_LOCAL),

				      semanage_path(SEMANAGE_TMP,

						    SEMANAGE_IBENDPORTS_LOCAL),

				      semanage_ibendport_dbase_local(sh)) < 0)

		goto err;

	/* Object databases: local modifications + policy */

	if (user_base_policydb_dbase_init(sh,

					  semanage_user_base_dbase_policy(sh)) <

	    0)

		goto err;

	if (user_extra_file_dbase_init(sh,

				       semanage_path(SEMANAGE_ACTIVE,

						     SEMANAGE_USERS_EXTRA),

				       semanage_path(SEMANAGE_TMP,

						     SEMANAGE_USERS_EXTRA),

				       semanage_user_extra_dbase_policy(sh)) <

	    0)

		goto err;

	if (user_join_dbase_init(sh,

				 semanage_user_base_dbase_policy(sh),

				 semanage_user_extra_dbase_policy(sh),

				 semanage_user_dbase_policy(sh)) < 0)

		goto err;

	if (port_policydb_dbase_init(sh, semanage_port_dbase_policy(sh)) < 0)

		goto err;

	if (ibpkey_policydb_dbase_init(sh, semanage_ibpkey_dbase_policy(sh)) < 0)

		goto err;

	if (ibendport_policydb_dbase_init(sh, semanage_ibendport_dbase_policy(sh)) < 0)

		goto err;

	if (iface_policydb_dbase_init(sh, semanage_iface_dbase_policy(sh)) < 0)

		goto err;

	if (bool_policydb_dbase_init(sh, semanage_bool_dbase_policy(sh)) < 0)

		goto err;

	if (fcontext_file_dbase_init(sh,

				     semanage_path(SEMANAGE_ACTIVE, SEMANAGE_STORE_FC),

				     semanage_path(SEMANAGE_TMP, SEMANAGE_STORE_FC),

				     semanage_fcontext_dbase_policy(sh)) < 0)

		goto err;

	if (seuser_file_dbase_init(sh,

				   semanage_path(SEMANAGE_ACTIVE, SEMANAGE_STORE_SEUSERS),

				   semanage_path(SEMANAGE_TMP, SEMANAGE_STORE_SEUSERS),

				   semanage_seuser_dbase_policy(sh)) < 0)

		goto err;

	if (node_policydb_dbase_init(sh, semanage_node_dbase_policy(sh)) < 0)

		goto err;

	/* Active kernel policy */

	if (bool_activedb_dbase_init(sh, semanage_bool_dbase_active(sh)) < 0)

		goto err;

	/* set the disable dontaudit value */

	path = semanage_path(SEMANAGE_ACTIVE, SEMANAGE_DISABLE_DONTAUDIT);

	if (stat(path, &sb) == 0)

		sepol_set_disable_dontaudit(sh->sepolh, 1);

	else if (errno == ENOENT) {

		/* The file does not exist */

		sepol_set_disable_dontaudit(sh->sepolh, 0);

	} else {

		ERR(sh, "Unable to access %s: %s\n", path, strerror(errno));

		goto err;

	}

	return STATUS_SUCCESS;

      err:

	ERR(sh, "could not establish direct connection");

	return STATUS_ERR;

}

static void semanage_direct_destroy(semanage_handle_t * sh

					__attribute__ ((unused)))

{

	/* do nothing */

}

static int semanage_remove_tmps(semanage_handle_t *sh)

{

	if (sh->commit_err)

		return 0;

	/* destroy sandbox if it exists */

	if (semanage_remove_directory

	    (semanage_path(SEMANAGE_TMP, SEMANAGE_TOPLEVEL)) < 0) {

		if (errno != ENOENT) {

			ERR(sh, "Could not cleanly remove sandbox %s.",

			    semanage_path(SEMANAGE_TMP, SEMANAGE_TOPLEVEL));

			return -1;

		}

	}

	/* destroy tmp policy if it exists */

	if (semanage_remove_directory

	    (semanage_final_path(SEMANAGE_FINAL_TMP,

				 SEMANAGE_FINAL_TOPLEVEL)) < 0) {

		if (errno != ENOENT) {

			ERR(sh, "Could not cleanly remove tmp %s.",

			    semanage_final_path(SEMANAGE_FINAL_TMP,

						SEMANAGE_FINAL_TOPLEVEL));

			return -1;

		}

	}

	return 0;

}

static int semanage_direct_disconnect(semanage_handle_t *sh)

{

	int retval = 0;

	/* destroy transaction and remove tmp files if no commit error */

	if (sh->is_in_transaction) {

		retval = semanage_remove_tmps(sh);

		semanage_release_trans_lock(sh);

	}

	/* Release object databases: local modifications */

	user_base_file_dbase_release(semanage_user_base_dbase_local(sh));

	user_extra_file_dbase_release(semanage_user_extra_dbase_local(sh));

	user_join_dbase_release(semanage_user_dbase_local(sh));

	port_file_dbase_release(semanage_port_dbase_local(sh));

	ibpkey_file_dbase_release(semanage_ibpkey_dbase_local(sh));

	ibendport_file_dbase_release(semanage_ibendport_dbase_local(sh));

	iface_file_dbase_release(semanage_iface_dbase_local(sh));

	bool_file_dbase_release(semanage_bool_dbase_local(sh));

	fcontext_file_dbase_release(semanage_fcontext_dbase_local(sh));

	fcontext_file_dbase_release(semanage_fcontext_dbase_homedirs(sh));

	seuser_file_dbase_release(semanage_seuser_dbase_local(sh));

	node_file_dbase_release(semanage_node_dbase_local(sh));

	/* Release object databases: local modifications + policy */

	user_base_policydb_dbase_release(semanage_user_base_dbase_policy(sh));

	user_extra_file_dbase_release(semanage_user_extra_dbase_policy(sh));

	user_join_dbase_release(semanage_user_dbase_policy(sh));

	port_policydb_dbase_release(semanage_port_dbase_policy(sh));

	ibpkey_policydb_dbase_release(semanage_ibpkey_dbase_policy(sh));

	ibendport_policydb_dbase_release(semanage_ibendport_dbase_policy(sh));

	iface_policydb_dbase_release(semanage_iface_dbase_policy(sh));

	bool_policydb_dbase_release(semanage_bool_dbase_policy(sh));

	fcontext_file_dbase_release(semanage_fcontext_dbase_policy(sh));

	seuser_file_dbase_release(semanage_seuser_dbase_policy(sh));

	node_policydb_dbase_release(semanage_node_dbase_policy(sh));

	/* Release object databases: active kernel policy */

	bool_activedb_dbase_release(semanage_bool_dbase_active(sh));

	return retval;

}

static int semanage_direct_begintrans(semanage_handle_t * sh)

{

	if (semanage_get_trans_lock(sh) < 0) {

		return -1;

	}

	if ((semanage_make_sandbox(sh)) < 0) {

		return -1;

	}

	if ((semanage_make_final(sh)) < 0) {

		return -1;

	}

	return 0;

}

/********************* utility functions *********************/

/* Takes a module stored in 'module_data' and parses its headers.

 * Sets reference variables 'module_name' to module's name, and

 * 'version' to module's version.  The caller is responsible for

 * free()ing 'module_name', and 'version'; they will be

 * set to NULL upon entering this function.  Returns 0 on success, -1

 * if out of memory.

 */

static int parse_module_headers(semanage_handle_t * sh, char *module_data,

                               size_t data_len, char **module_name,

                               char **version)

{

       struct sepol_policy_file *pf;

       int file_type;

       *module_name = *version = NULL;

       if (sepol_policy_file_create(&pf)) {

               ERR(sh, "Out of memory!");

               return -1;

       }

       sepol_policy_file_set_mem(pf, module_data, data_len);

       sepol_policy_file_set_handle(pf, sh->sepolh);

       if (module_data != NULL && data_len > 0)

           sepol_module_package_info(pf, &file_type, module_name,

                                     version);

       sepol_policy_file_free(pf);

       return 0;

}

#include <stdlib.h>

#include <bzlib.h>

#include <string.h>

#include <sys/sendfile.h>

/* bzip() a data to a file, returning the total number of compressed bytes

 * in the file.  Returns -1 if file could not be compressed. */

static ssize_t bzip(semanage_handle_t *sh, const char *filename, char *data,

			size_t num_bytes)

{

	BZFILE* b;

	size_t  size = 1<<16;

	int     bzerror;

	size_t  total = 0;

	size_t len = 0;

	FILE *f;

	if ((f = fopen(filename, "wb")) == NULL) {

		return -1;

	}

	if (!sh->conf->bzip_blocksize) {

		if (fwrite(data, 1, num_bytes, f) < num_bytes) {

			fclose(f);

			return -1;

		}

		fclose(f);

		return num_bytes;

	}

	b = BZ2_bzWriteOpen( &bzerror, f, sh->conf->bzip_blocksize, 0, 0);

	if (bzerror != BZ_OK) {

		BZ2_bzWriteClose ( &bzerror, b, 1, 0, 0 );

		return -1;

	}

	while ( num_bytes > total ) {

		if (num_bytes - total > size) {

			len = size;

		} else {

			len = num_bytes - total;

		}

		BZ2_bzWrite ( &bzerror, b, &data[total], len );

		if (bzerror == BZ_IO_ERROR) { 

			BZ2_bzWriteClose ( &bzerror, b, 1, 0, 0 );

			return -1;

		}

		total += len;

	}

	BZ2_bzWriteClose ( &bzerror, b, 0, 0, 0 );

	fclose(f);

	if (bzerror == BZ_IO_ERROR) {

		return -1;

	}

	return total;

}

#define BZ2_MAGICSTR "BZh"

#define BZ2_MAGICLEN (sizeof(BZ2_MAGICSTR)-1)

/* bunzip() a file to '*data', returning the total number of uncompressed bytes

 * in the file.  Returns -1 if file could not be decompressed. */

ssize_t bunzip(semanage_handle_t *sh, FILE *f, char **data)

{

	BZFILE* b = NULL;

	size_t  nBuf;

	char*   buf = NULL;

	size_t  size = 1<<18;

	size_t  bufsize = size;

	int     bzerror;

	size_t  total=0;

	char*   uncompress = NULL;

	char*   tmpalloc = NULL;

	int     ret = -1;

	buf = malloc(bufsize);

	if (buf == NULL) {

		ERR(sh, "Failure allocating memory.");

		goto exit;

	}

	/* Check if the file is bzipped */

	bzerror = fread(buf, 1, BZ2_MAGICLEN, f);

	rewind(f);

	if ((bzerror != BZ2_MAGICLEN) || memcmp(buf, BZ2_MAGICSTR, BZ2_MAGICLEN)) {

		goto exit;

	}

	b = BZ2_bzReadOpen ( &bzerror, f, 0, sh->conf->bzip_small, NULL, 0 );

	if ( bzerror != BZ_OK ) {

		ERR(sh, "Failure opening bz2 archive.");

		goto exit;

	}

	uncompress = malloc(size);

	if (uncompress == NULL) {

		ERR(sh, "Failure allocating memory.");

		goto exit;

	}

	while ( bzerror == BZ_OK) {

		nBuf = BZ2_bzRead ( &bzerror, b, buf, bufsize);

		if (( bzerror == BZ_OK ) || ( bzerror == BZ_STREAM_END )) {

			if (total + nBuf > size) {

				size *= 2;

				tmpalloc = realloc(uncompress, size);

				if (tmpalloc == NULL) {

					ERR(sh, "Failure allocating memory.");

					goto exit;

				}

				uncompress = tmpalloc;

			}

			memcpy(&uncompress[total], buf, nBuf);

			total += nBuf;

		}

	}

	if ( bzerror != BZ_STREAM_END ) {

		ERR(sh, "Failure reading bz2 archive.");

		goto exit;

	}

	ret = total;

	*data = uncompress;

exit:

	BZ2_bzReadClose ( &bzerror, b );

	free(buf);

	if ( ret < 0 ) {

		free(uncompress);

	}

	return ret;

}

/* mmap() a file to '*data',

 *  If the file is bzip compressed map_file will uncompress 

 * the file into '*data'.

 * Returns the total number of bytes in memory .

 * Returns -1 if file could not be opened or mapped. */

static ssize_t map_file(semanage_handle_t *sh, const char *path, char **data,

			int *compressed)

{

	ssize_t size = -1;

	char *uncompress;

	int fd = -1;

	FILE *file = NULL;

	fd = open(path, O_RDONLY);

	if (fd == -1) {

		ERR(sh, "Unable to open %s\n", path);

		return -1;

	}

	file = fdopen(fd, "r");

	if (file == NULL) {

		ERR(sh, "Unable to open %s\n", path);

		close(fd);

		return -1;

	}

	if ((size = bunzip(sh, file, &uncompress)) > 0) {

		*data = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);

		if (*data == MAP_FAILED) {

			free(uncompress);

			fclose(file);

			return -1;

		} else {

			memcpy(*data, uncompress, size);

		}

		free(uncompress);

		*compressed = 1;

	} else {

		struct stat sb;

		if (fstat(fd, &sb) == -1 ||

		    (*data = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) ==

		    MAP_FAILED) {

			size = -1;

		} else {

			size = sb.st_size;

		}

		*compressed = 0;

	} 

	fclose(file);

	return size;

}

/* Writes a block of data to a file.  Returns 0 on success, -1 on

 * error. */

static int write_file(semanage_handle_t * sh,

		      const char *filename, char *data, size_t num_bytes)

{

	int out;

	if ((out =

	     open(filename, O_WRONLY | O_CREAT | O_TRUNC,

		  S_IRUSR | S_IWUSR)) == -1) {

		ERR(sh, "Could not open %s for writing.", filename);

		return -1;

	}

	if (write(out, data, num_bytes) == -1) {

		ERR(sh, "Error while writing to %s.", filename);

		close(out);

		return -1;

	}

	close(out);

	return 0;

}

static int semanage_direct_update_user_extra(semanage_handle_t * sh, cil_db_t *cildb)

{

	const char *ofilename = NULL;

	int retval = -1;

	char *data = NULL;

	size_t size = 0;

	dbase_config_t *pusers_extra = semanage_user_extra_dbase_policy(sh);

	retval = cil_userprefixes_to_string(cildb, &data, &size);

	if (retval != SEPOL_OK) {

		goto cleanup;

	}

	if (size > 0) {

		/*

		 * Write the users_extra entries from CIL modules.

		 * This file is used as our baseline when we do not require

		 * re-linking.

		 */

		ofilename = semanage_path(SEMANAGE_TMP,

					  SEMANAGE_USERS_EXTRA_LINKED);

		if (ofilename == NULL) {

			retval = -1;

			goto cleanup;

		}

		retval = write_file(sh, ofilename, data, size);

		if (retval < 0)

			goto cleanup;

		/*

		 * Write the users_extra file; users_extra.local

		 * will be merged into this file.

		 */

		ofilename = semanage_path(SEMANAGE_TMP, SEMANAGE_USERS_EXTRA);

		if (ofilename == NULL) {

			retval = -1;

			goto cleanup;

		}

		retval = write_file(sh, ofilename, data, size);

		if (retval < 0)

			goto cleanup;

		pusers_extra->dtable->drop_cache(pusers_extra->dbase);

	} else {

		retval =  pusers_extra->dtable->clear(sh, pusers_extra->dbase);

	}

cleanup:

	free(data);

	return retval;

}

static int semanage_direct_update_seuser(semanage_handle_t * sh, cil_db_t *cildb)

{

	const char *ofilename = NULL;

	int retval = -1;

	char *data = NULL;

	size_t size = 0;

	dbase_config_t *pseusers = semanage_seuser_dbase_policy(sh);

	retval = cil_selinuxusers_to_string(cildb, &data, &size);

	if (retval != SEPOL_OK) {

		goto cleanup;

	}

	if (size > 0) {

		/*

		 * Write the seusers entries from CIL modules.

		 * This file is used as our baseline when we do not require

		 * re-linking.

		 */

		ofilename = semanage_path(SEMANAGE_TMP,

					  SEMANAGE_SEUSERS_LINKED);

		if (ofilename == NULL) {

			retval = -1;

			goto cleanup;

		}

		retval = write_file(sh, ofilename, data, size);

		if (retval < 0)

			goto cleanup;

		/*

		 * Write the seusers file; seusers.local will be merged into

		 * this file.

		 */

		ofilename = semanage_path(SEMANAGE_TMP, SEMANAGE_STORE_SEUSERS);

		if (ofilename == NULL) {

			retval = -1;

			goto cleanup;

		}

		retval = write_file(sh, ofilename, data, size);

		if (retval < 0)

			goto cleanup;

		pseusers->dtable->drop_cache(pseusers->dbase);

	} else {

		retval = pseusers->dtable->clear(sh, pseusers->dbase);

	}

cleanup:

	free(data);

	return retval;

}

static int read_from_pipe_to_data(semanage_handle_t *sh, size_t initial_len, int fd, char **out_data_read, size_t *out_read_len)

{

	size_t max_len = initial_len;

	size_t read_len = 0;

	size_t data_read_len = 0;

	char *data_read = NULL;

	if (max_len <= 0) {

		max_len = 1;

	}

	data_read = malloc(max_len * sizeof(*data_read));

	if (data_read == NULL) {

		ERR(sh, "Failed to malloc, out of memory.\n");

		return -1;

	}

	while ((read_len = read(fd, data_read + data_read_len, max_len - data_read_len)) > 0) {

		data_read_len += read_len;

		if (data_read_len == max_len) {

			max_len *= 2;

			data_read = realloc(data_read, max_len);

			if (data_read == NULL) {

				ERR(sh, "Failed to realloc, out of memory.\n");

				return -1;

			}

		}

	}

	*out_read_len = data_read_len;

	*out_data_read = data_read;

	return 0;

}

static int semanage_pipe_data(semanage_handle_t *sh, char *path, char *in_data, size_t in_data_len, char **out_data, size_t *out_data_len, char **err_data, size_t *err_data_len)

{

	int input_fd[2] = {-1, -1};

	int output_fd[2] = {-1, -1};

	int err_fd[2] = {-1, -1};

	pid_t pid;

	char *data_read = NULL;

	char *err_data_read = NULL;

	int retval;

	int status = 0;

	size_t initial_len;

	size_t data_read_len = 0;

	size_t err_data_read_len = 0;

	struct sigaction old_signal;

	struct sigaction new_signal;

	new_signal.sa_handler = SIG_IGN;

	sigemptyset(&new_signal.sa_mask);

	new_signal.sa_flags = 0;

	/* This is needed in case the read end of input_fd is closed causing a SIGPIPE signal to be sent.

	 * If SIGPIPE is not caught, the signal will cause semanage to terminate immediately. The sigaction below

	 * creates a new_signal that ignores SIGPIPE allowing the write to exit cleanly.

	 *

	 * Another sigaction is called in cleanup to restore the original behavior when a SIGPIPE is received.

	 */

	sigaction(SIGPIPE, &new_signal, &old_signal);

	retval = pipe(input_fd);

	if (retval == -1) {

		ERR(sh, "Unable to create pipe for input pipe: %s\n", strerror(errno));

		goto cleanup;

	}

	retval = pipe(output_fd);

	if (retval == -1) {

		ERR(sh, "Unable to create pipe for output pipe: %s\n", strerror(errno));

		goto cleanup;

	}

	retval = pipe(err_fd);

	if (retval == -1) {

		ERR(sh, "Unable to create pipe for error pipe: %s\n", strerror(errno));

		goto cleanup;

	}

	pid = fork();

	if (pid == -1) {

		ERR(sh, "Unable to fork from parent: %s.", strerror(errno));

		retval = -1;

		goto cleanup;

	} else if (pid == 0) {

		retval = dup2(input_fd[PIPE_READ], STDIN_FILENO);

		if (retval == -1) {

			ERR(sh, "Unable to dup2 input pipe: %s\n", strerror(errno));

			goto cleanup;

		}

		retval = dup2(output_fd[PIPE_WRITE], STDOUT_FILENO);

		if (retval == -1) {

			ERR(sh, "Unable to dup2 output pipe: %s\n", strerror(errno));

			goto cleanup;

		}

		retval = dup2(err_fd[PIPE_WRITE], STDERR_FILENO);

		if (retval == -1) {

			ERR(sh, "Unable to dup2 error pipe: %s\n", strerror(errno));

			goto cleanup;

		}

		retval = close(input_fd[PIPE_WRITE]);

		if (retval == -1) {

			ERR(sh, "Unable to close input pipe: %s\n", strerror(errno));

			goto cleanup;

		}

		retval = close(output_fd[PIPE_READ]);

		if (retval == -1) {

			ERR(sh, "Unable to close output pipe: %s\n", strerror(errno));

			goto cleanup;

		}

		retval = close(err_fd[PIPE_READ]);

		if (retval == -1) {

			ERR(sh, "Unable to close error pipe: %s\n", strerror(errno));

			goto cleanup;

		}